home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / m2 / cat3src / cat / fred.m < prev    next >
Text File  |  1997-10-26  |  142KB  |  4,070 lines
  1. MODULE Fred;
  2.  
  3. (*==============================================================*
  4.  * Modul:               Fred - der Editor Main Modul            *
  5.  * Autor:               Dirk Steins                             *
  6.  * erstellt am:         4.11.1991                               *
  7.  * letzte Žnderung am:  17.4.1994                               *
  8.  * Version:             0.91                                    *
  9.  * Interne Version:     V#0089                                  *
  10.  *==============================================================*
  11.  
  12.  *----------------------------------------------------------------------------
  13.  * Datum    Vers. Autor Žnderung (Arbeitsbericht)                            
  14.  *----------------------------------------------------------------------------
  15.  * 4.11.91  0.1   DS    Modul erstellt                                                                      
  16.  *
  17.  * 8.4.92   0.35  DS    umgestellt auf neue Window-Library
  18.  * 18.4.95  0.91  DS    angepažt an CAT_GOLD-Sourcen
  19.  * 5.6.95   0.92  DS    neu compiliert mit aktuelleren Sourcen
  20.  *----------------------------------------------------------------------------
  21.  *)
  22.  
  23. (* Fr Fehlerbehandlung unter der Shell: *)
  24. FROM PrgCtrl            IMPORT CatchProcessTerm, TermCarrier, TermProcess;
  25. FROM MOSGlobals         IMPORT MemArea;
  26. IMPORT MOSCtrl;
  27.  
  28. (*IMPORT GEMDOSIO;
  29. IMPORT InOut; *)
  30. FROM SYSTEM             IMPORT ADDRESS, ADR, CODE, CADR, ASSEMBLER, TSIZE;
  31. FROM Storage            IMPORT ALLOCATE, DEALLOCATE, MemAvail;
  32.  
  33. (* MM2-spezifische Libs! *)
  34. FROM Characters         IMPORT CR, LF;
  35.  
  36. IMPORT  StrConv,
  37.         Strings,        (* String-Operationen *)
  38.         Paths,          (* Pfadliste          *)
  39.         ShellMsg,       (* Variablen der Shell*)
  40.         Lists,          (* Fr Listenooperationen auf den Pfadlisten *)
  41.         FileNames;      (* String-Operationen auf Dateinamen *)
  42.  
  43. (* Magic-Module *)
  44. IMPORT MagicAES;
  45. IMPORT MagicVDI;
  46. IMPORT MagicDOS;
  47. IMPORT MagicXBIOS;
  48. IMPORT MagicCookie;
  49. IMPORT mtAppl;
  50. IMPORT mtCommand;
  51. IMPORT mtUtils;
  52. IMPORT mtDials;
  53. IMPORT mtDir;
  54. IMPORT mtAlerts;
  55. IMPORT mtPopups;
  56. IMPORT mtTime;
  57. IMPORT mtTextfiles;
  58. IMPORT MagicSys;
  59. IMPORT MagicStrings;
  60. IMPORT MagicConvert;
  61.  
  62. IMPORT MintUtil;
  63. IMPORT Mintbind;
  64.  
  65. (* CAT-Module *)
  66. IMPORT  CatTypes,       (* Ein paar Typ-Definitionen    *)
  67.         CatEdit,        (* Der eigentliche Editor :-)   *)
  68.         EditFuncs,      (* Noch ein paar Funktionen     *)
  69.         EditTypes;      (* Typen fr den Editor         *)
  70. IMPORT WdwManager;      (* Window-Library               *)
  71. IMPORT FontSelect;
  72. IMPORT CatFiles;
  73. IMPORT Printer;
  74.  
  75. FROM Void               IMPORT v;
  76. FROM SearchMenu         IMPORT MenuSearch;
  77. FROM SwapServer         IMPORT SplitWordToByte, SmallerCard;
  78. IMPORT ShellCall;
  79.  
  80. FROM CatGlobal           IMPORT FselGet;
  81. IMPORT CatGlobal;
  82.  
  83. IMPORT Varnames;
  84. IMPORT ConfVars;
  85. IMPORT AssFuncs;
  86. IMPORT Find2;
  87. IMPORT WinDials;
  88.  
  89. (* FRED-Module *)
  90. IMPORT WildCards;
  91. IMPORT PListHelp;
  92. FROM FredProtokoll      IMPORT IsProtokoll, React, SendTerminate, 
  93.                                SendOpenwind, SendHelp, ProtoInit,
  94.                                SeProtoInit, SendEsMessage,
  95.                                SEProtoActiv;
  96. IMPORT SEProto;
  97. (* Resource Definitions *)
  98.  
  99. IMPORT Fredrsc;
  100.  
  101. CONST   pVersion        = ' 0.96 ž';
  102.  
  103.         pDate           = '26.10.1997';
  104.  
  105.         eddixName       = '  Fred'+pVersion+0C;
  106.  
  107.         sysStrOne       = 'Shell aufrufen';
  108.         blockSaveAs     = 'Block sichern als...';
  109.         saveAs          = 'Sichern als...';
  110.         
  111.         wrongWildAlert  = '[2][FRED:|Die Wildcardzeichen sind|nicht korrekt!|Bitte korrigierenm Sie|Ihre Eingaben!][[OK]';
  112.         wrongWildReplace  = '[3][FRED:|Die Zuordnung der Wildcards|ist nicht eindeutig!][[Abbruch]';
  113.         noSearchStr     = "[3][FRED:|Fehler im Suchmuster!|Suchstrings, die nur aus|Wildcardzeichen bestehen,|sind nicht erlaubt!][[Nochmal]";
  114.         NoWinDial       = "[3][FRED:|Es ist kein Fenster|fr den Dialog verfgbar!|Bitte schliežen sie ein|anderes Fenster.][[OK]";
  115.         
  116.         cfgNotFound     = '[3][FRED:|CFG-File nicht|gefunden!][[Abbruch]';
  117.         noCfgFile       = '[3][FRED:|Diese Datei ist|keine CFG-Datei!][[Abbruch]';
  118.         
  119.         maxLineLength   = 4096;
  120.  
  121.         magicPCCookie = 'MgPC';
  122.  
  123. CONST whatString = '@(#)Fred '+pVersion + ', Copyright (c) 1997 Dirk Steins (Oct 26 1997)'+0C;
  124.  
  125.     (* Variablennamen fr CFG-File *)
  126.     cErrExtension   = 'ErrorExtension';
  127.     cErrMask        = 'ErrorMask';
  128.     cHelpLine       = 'HelpLineLayout';
  129.     cPrjExtension   = 'ProjectExtension';
  130.     (*
  131.     cExtension      = 'Extension';
  132.     cExtTabsize     = 'ExtTabSize';
  133.     cExtHardTabs    = 'ExtHardTabs';
  134.     cExtWordWrap    = 'ExtWordWrap';
  135.     cExtRightMargin = 'ExtRightMargin';
  136.     cExtAutoBackup  = 'ExtAutoBackup';
  137.     *)
  138.     cSourcePath     = 'SourcePath';
  139.     cNormalFkey     = 'NormalF';
  140.     cAutoSavePrefs  = 'AutoSavePrefs';
  141.     cShortFile      = 'LastShortcutFile';
  142.  
  143. TYPE magixCookiePtr = POINTER TO magixRecord;
  144.      magixRecord    = RECORD
  145.                         confStatus : LONGCARD;
  146.                         dosVars    : ADDRESS;
  147.                         aesVars    : ADDRESS;
  148.                       END;
  149. CONST
  150.      allWild    = '*.*';
  151.  
  152. CONST   maxErrFiles = 4;
  153.  
  154. TYPE    listRecord  = RECORD
  155.                         wdw : INTEGER;
  156.                         fname: CatTypes.String255;
  157.                       END;
  158.         errorArray  = ARRAY [0..maxErrFiles-1] OF listRecord;
  159.  
  160.  
  161. VAR     errIndex: INTEGER;
  162.         errFiles: errorArray;
  163.         errMask : CatTypes.String255;
  164.  
  165. TYPE CharSet    = SET OF CHAR;
  166.      
  167.      MaxStr     = ARRAY [0..255] OF CHAR;
  168.      PtrMaxStr  = POINTER TO MaxStr;
  169.  
  170.  
  171. (* Wirklich benutzte Variable: *)
  172.  
  173. VAR
  174.         InSel           : ARRAY[0..40] OF CHAR;
  175.         SaveName        : ARRAY[0..40] OF CHAR;
  176.  
  177.         SCAN            : INTEGER;
  178.         CH              : CHAR;
  179.         moButton        : BITSET;
  180.         kReturn         : INTEGER;
  181.         moKState        : BITSET;
  182.         moX, moY        : INTEGER;
  183.         bReturn         : INTEGER;
  184.         event           : BITSET;
  185.         e               : BITSET;
  186.         scan,                   
  187.         char            : CHAR; 
  188.         null            : RECORD d1,d2 : LONGCARD END;
  189.         mess,
  190.         mScrap          : ARRAY[0..7] OF INTEGER;
  191.  
  192.         dr, mrect       : RECORD
  193.                             CASE :BOOLEAN OF
  194.                               TRUE : x,y,w,h : INTEGER|
  195.                               FALSE: adr, dum: ADDRESS
  196.                             END
  197.                           END;
  198.         mouse           : BOOLEAN;
  199.  
  200.         apId            : CARDINAL;
  201.         devHdl          : INTEGER;
  202.  
  203.         (* Adressen der Objektb„ume *)        
  204.         menu            : ADDRESS;
  205.         infoBox,
  206.         aboutBox,
  207.         lineBox,
  208.         tabBox,
  209.         umbruchBox,
  210.         floskelBox,
  211.         gotoBox,
  212.         systemBox,
  213.         pathBox,
  214.         fredIcon,
  215.         shortBox,
  216.         errorBox,
  217.         suchBox         : ADDRESS;
  218.  
  219.         (* Pfade *)        
  220.         homePath        : MaxStr;
  221.         InPath          : MaxStr;
  222.         SavePath        : MaxStr;
  223.         
  224.         (* Letzter Dateiname: *)
  225.         OpenName        : ARRAY[0..12] OF CHAR;
  226.         
  227.         (* Falls TRUE, dann Programm beenden *)
  228.         quitProg        : BOOLEAN;
  229.         termCode        : INTEGER;      (* Return-Code fr Shell *)
  230.         
  231.         (* Such- und Ersetzeinstellungen  *)
  232.         replaceOpts,
  233.         searchOpts      : RECORD
  234.                             isSet,
  235.                             doIt,
  236.                             ignoreCase,
  237.                             askBack,
  238.                             onlyWord:         BOOLEAN;
  239.                             theSearchWdw:     INTEGER;
  240.                             direction:        EditTypes.searchDir;
  241.                             count:            EditTypes.searchCount;
  242.                             pos:              EditTypes.searchPos;
  243.                             number:           INTEGER;
  244.                             searchStr,
  245.                             replaceStr:       ARRAY[0..79] OF CHAR;
  246.                           END;
  247.        
  248.         mm2shell        : BOOLEAN; (* l„uft als Modul unter der MM2Shell *)
  249.         
  250.         shell           : ShellCall.shellType;  (* CLI type if available *)
  251.         
  252.         infoName        : ARRAY [0..255] OF CHAR;
  253.         
  254.         autoSavePos     : BOOLEAN;
  255.         filterNumber    : INTEGER;
  256.         
  257.         oldSrcPaths     : Lists.List;
  258.         
  259.         (* Fr Krzeldateien *)
  260.         shortFileRead   : BOOLEAN;
  261.         lastShort       : MaxStr;
  262.         
  263. (* Kleiner Stack fr Keyboard-Events *)
  264. CONST   maxKeys = 16;
  265. TYPE    kbdEvent    = RECORD
  266.                         kstate : BITSET;
  267.                         scan   : CHAR;
  268.                         ch     : CHAR;
  269.                       END;
  270. VAR keyStack    : ARRAY [0..maxKeys-1] OF kbdEvent;
  271.     keyWrite    : INTEGER;
  272.     keyRead     : INTEGER;
  273.  
  274. PROCEDURE PopKey (VAR kstate: BITSET; VAR scan : CHAR; VAR ch : CHAR);
  275. BEGIN
  276.   IF keyRead # keyWrite THEN
  277.     kstate := keyStack[keyRead].kstate;
  278.     scan   := keyStack[keyRead].scan;
  279.     ch     := keyStack[keyRead].ch;
  280.     keyRead := (keyRead + 1) MOD maxKeys;
  281.   END;
  282. END PopKey;
  283.  
  284. PROCEDURE PushKey (kstate: BITSET; scan, ch : CHAR);
  285. BEGIN
  286.   keyStack[keyWrite].kstate := kstate;
  287.   keyStack[keyWrite].scan   := scan;
  288.   keyStack[keyWrite].ch     := ch;
  289.   keyWrite := (keyWrite + 1) MOD maxKeys;
  290.   IF keyWrite = keyRead THEN 
  291.     (* hat keyRead eingeholt, einmal rum! 
  292.      * keyRead auf n„chsten setzen 
  293.      *)
  294.     keyRead := (keyWrite + 1) MOD maxKeys;
  295.   END;
  296. END PushKey;
  297.  
  298. PROCEDURE PendingKey (): BOOLEAN;
  299. BEGIN
  300.   RETURN keyRead # keyWrite;
  301. END PendingKey;
  302.  
  303. PROCEDURE noWinDialAlert(); 
  304.  (* Damit nich dauernd die Strings berall eingesetzt werden, hier ein zentraler Aufruf *)
  305. BEGIN 
  306.   v.int := mtAlerts.Alert (1, NoWinDial) 
  307. END noWinDialAlert;
  308.  
  309. CONST   cCfgName = 'fred.cfg';
  310.  
  311. PROCEDURE PathsToConf();
  312.   VAR entry: CatTypes.Str255Ptr;
  313.       count: INTEGER;
  314.       varname : CatTypes.String127;
  315. BEGIN
  316.   Lists.ResetList (ShellMsg.SrcPaths);
  317.   entry := Lists.NextEntry (ShellMsg.SrcPaths);
  318.   count := 1;
  319.   WHILE entry # NIL DO
  320.     Strings.Assign (cSourcePath, varname, v.bool);
  321.     Strings.Append (StrConv.IntToStr (count, 0), varname, v.bool);
  322.     v.bool := ConfVars.SetConfigString (varname, entry^);
  323.     entry := Lists.NextEntry (ShellMsg.SrcPaths);
  324.     INC (count);
  325.   END;
  326. END PathsToConf;
  327.  
  328. (*$Z-*)
  329. PROCEDURE findName (e, i : ADDRESS): BOOLEAN;
  330.   VAR entry : CatTypes.Str255Ptr;
  331.       str   : CatTypes.Str255Ptr;
  332. BEGIN
  333.   entry := e;
  334.   str := i;
  335.   RETURN AssFuncs.StrIequal (entry^, str^);
  336. END findName;
  337. (*$Z=*)
  338.  
  339. PROCEDURE ConfToPaths();
  340.   VAR entry: CatTypes.Str255Ptr;
  341.       new  : CatTypes.Str255Ptr;
  342.       path : CatTypes.String255;
  343.       count: INTEGER;
  344.       varname : CatTypes.String127;
  345.       newList : Lists.List;
  346.       ok   : BOOLEAN;
  347. BEGIN
  348.   IF MOSCtrl.ModLevel = 1
  349.   THEN
  350.     (* Wenn unter der Shell, dann existiert die Liste schon! *)
  351.     Lists.CreateList (ShellMsg.SrcPaths, v.bool);
  352.   ELSE
  353.     (* Da die d„mlicherweise in einem komischen Array gespeichert sind,
  354.      * baue ich die Liste neu auf und setze sie am Programmende zurck
  355.      *)
  356.     Lists.CreateList (newList, v.bool);
  357.     IF ~v.bool
  358.     THEN
  359.       Lists.ResetList (ShellMsg.SrcPaths);
  360.       entry := Lists.NextEntry (ShellMsg.SrcPaths);
  361.       WHILE entry # NIL DO
  362.         ALLOCATE (new, LENGTH (entry^)+1);
  363.         IF new # NIL
  364.         THEN
  365.           Strings.Assign (entry^, new^, v.bool);
  366.           Lists.AppendEntry (newList, new, v.bool);
  367.         END;
  368.         entry := Lists.NextEntry (ShellMsg.SrcPaths);
  369.       END;
  370.       (* Jetzt die Listen austauschen *)
  371.       oldSrcPaths := ShellMsg.SrcPaths;
  372.       ShellMsg.SrcPaths := newList;
  373.     END;
  374.   END;
  375.   count := 1;
  376.   WHILE count < 255 DO
  377.     Strings.Assign (cSourcePath, varname, v.bool);
  378.     Strings.Append (StrConv.IntToStr (count, 0), varname, v.bool);
  379.     IF ConfVars.GetConfigString (varname, path)
  380.     THEN
  381.       (* Erstmal sehen, ob der Pfad nicht schon in der Liste ist *)
  382.       Lists.ResetList (ShellMsg.SrcPaths);
  383.       Lists.ScanEntries (ShellMsg.SrcPaths, Lists.forward, findName, ADR(path), ok);
  384.       IF ~ok
  385.       THEN
  386.         NEW (entry);
  387.         IF entry = NIL
  388.         THEN RETURN 
  389.         END;
  390.         Strings.Assign (path, entry^, v.bool);
  391.         Lists.AppendEntry (ShellMsg.SrcPaths, entry, v.bool);
  392.         IF v.bool THEN RETURN END;
  393.       END;
  394.       ConfVars.DeleteConfigVar (varname);
  395.     END;
  396.     INC (count);
  397.   END;
  398. END ConfToPaths;
  399.  
  400. PROCEDURE LoadPrefs ();
  401. (* l„dt Default-Einstellungen und setzt diese,
  402.  * falls kein Infofile vorhanden 
  403.  *)
  404.   VAR cfgFile : CatTypes.String255;
  405. BEGIN
  406.   (* Jetzt Infofile holen
  407.    * Name: FRED.CFG 
  408.    *)
  409.   MagicStrings.Assign (homePath, infoName);
  410.   Strings.Append (cCfgName, infoName, v.bool);
  411.   v.bool := ConfVars.ReadConfigFile (infoName);
  412.   ConfToPaths();
  413.   CatGlobal.SetColors();
  414.   IF ConfVars.GetConfigString (cPrtCfg, cfgFile)
  415.   THEN
  416.     Printer.LoadCFGFile (cfgFile);
  417.   END;
  418. END LoadPrefs;
  419.  
  420. PROCEDURE fredInfo (REF inf: mtTextfiles.TEXTFILE);
  421.   VAR z1 : CARDINAL;
  422.       d, m, y : CARDINAL;
  423.       mname  : ARRAY [0..3] OF CHAR;
  424.       tstr   : ARRAY [0..12] OF CHAR;
  425. BEGIN
  426.   mtTextfiles.WriteLine (inf, '# ');
  427.   mtTextfiles.WriteLine (inf, whatString);
  428.   mtTextfiles.WriteLn (inf);
  429.   z1 := MagicDOS.Tgetdate();
  430.   mtTime.DecodeDate (z1, d, m, y);
  431.   mtTime.NameOfMonth (mtTime.English, m, mname);
  432.   mname[3] := ' ';
  433.   mtTextfiles.WriteLine (inf, '# created ');
  434.   mtTextfiles.WriteLine (inf, mname);
  435.   mtTextfiles.WriteCard (inf, d, 0);
  436.   mtTextfiles.WriteLine (inf, ' ');
  437.   mtTextfiles.WriteCard (inf, y, 0);
  438.   mtTextfiles.WriteLine (inf, ', ');
  439.   mtTime.TimeString (MagicDOS.Tgettime(), tstr);
  440.   mtTextfiles.WriteLine (inf, tstr);
  441.   mtTextfiles.WriteLn (inf);
  442. END fredInfo;
  443.  
  444. PROCEDURE SavePrefs ();
  445. BEGIN
  446.   CatGlobal.ApplPath (infoName);
  447.   Strings.Append (cCfgName, infoName, v.bool);
  448.   CatEdit.EditSavePos();
  449.   (* Pfade in Variable sichern *)
  450.   PathsToConf();
  451.   v.bool := ConfVars.WriteConfigFile (infoName, fredInfo);
  452. END SavePrefs;
  453.  
  454. PROCEDURE GetHomePath();
  455. VAR applpath:   MaxStr;
  456.     shelPath:   MaxStr;
  457.     shelCmd:    MaxStr;
  458. BEGIN
  459.   CatGlobal.SetAppl ('FRED');
  460.   CatGlobal.GetApplPath (applpath);
  461.   Strings.Assign (applpath, homePath, v.bool);
  462.   (* Aktuellen Pfad holen *)
  463.   Strings.Assign('', InPath, v.bool);
  464.   mtDir.GetPath (InPath);
  465.   Strings.Assign(InPath, SavePath, v.bool);
  466. END GetHomePath;
  467.  
  468. PROCEDURE InitResource (VAR resourceName : ARRAY OF CHAR) : BOOLEAN;
  469.   
  470.   CONST
  471.         noRscAlt        = '[5][Kann das Resource-File|FRED.RSC nicht laden][[Schade..]';
  472.         
  473.         noLowResAlt     = '[4][Die gew„hlte Aufl”sung|ist zu niedrig|fr FRED!][ [OK ]';
  474.         
  475.   VAR success     : BOOLEAN;
  476.       screenColumns : CARDINAL;
  477.       box         : MagicAES.BoxInfo;
  478.       rscLoaded   : BOOLEAN;
  479.       rscString   : MaxStr;
  480. BEGIN
  481.   
  482.   devHdl := mtAppl.VDIHandle;
  483.  
  484.   apId  := mtAppl.ApplIdent;
  485.   
  486.   GetHomePath();
  487.   
  488.   (* 80-Zeichen Bildschirm wird verlangt! *)
  489.   screenColumns := mtAppl.MaxWidth DIV mtAppl.CharWidth;
  490.   
  491.   IF screenColumns < 80
  492.   THEN
  493.     v.int := mtAlerts.Alert(1,noLowResAlt);
  494.     RETURN FALSE
  495.   END;
  496.  
  497.   (* Resource laden und Baumaddressen ermitteln *)
  498.   rscLoaded := MagicAES.RsrcLoad (resourceName);
  499.   
  500. (* Sollte eigentlich berflssig sein, da rsrcload ein shelfind macht!  *)
  501.   IF ~rscLoaded
  502.   THEN
  503.     (* Auf den Shellpfaden suchen ! *)
  504.     Paths.SearchFile (resourceName, ShellMsg.StdPaths, Paths.fromStart, v.bool, rscString);
  505.     IF v.bool
  506.     THEN
  507.       rscLoaded := MagicAES.RsrcLoad (rscString);
  508.     END;
  509.   END;
  510.  
  511.   IF ~rscLoaded
  512.   THEN
  513.     Strings.Assign ('fredrsc.rsc', resourceName, v.bool);
  514.     rscLoaded := MagicAES.RsrcLoad (resourceName);
  515.   END;
  516.  
  517.   IF ~rscLoaded
  518.   THEN
  519.     mtAlerts.SetIconColor (MagicAES.RED);
  520.     v.int := mtAlerts.Alert (1,noRscAlt);
  521.     RETURN FALSE
  522.   END;
  523.   
  524.   LoadPrefs;
  525.   
  526.   infoBox       := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Fileinfo);
  527.   aboutBox      := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Aboutbox);
  528.   lineBox       := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Linebox );
  529.   tabBox        := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Tabbox  );
  530.   umbruchBox    := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Umbruch );
  531.   gotoBox       := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Gotobox );
  532.   systemBox     := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Systembx);
  533.   suchBox       := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Suchbox);
  534.   pathBox       := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Pfade);
  535.   fredIcon      := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Fredicon);
  536.   shortBox      := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Shortbox);
  537.   errorBox      := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Errbox);
  538.   menu          := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Menu);
  539.   
  540.   (* Versionsnummer einsetzen *)
  541.   mtUtils.SetObjcString (aboutBox, Fredrsc.Version, pVersion);
  542.   mtUtils.SetObjcString (aboutBox, Fredrsc.Vdate, pDate);
  543.   
  544.   (* Bit Images anpassen *)
  545. (*!!  
  546.   transObj (aboutBox, Fredrsc.Edixlogo, devHdl);
  547.   transObj (aboutBox, Fredrsc.Logo2, devHdl);
  548. *)
  549. (*  Behalten fr Slider bei Laden/Speichern
  550.   (* Infoslider anpassen: Fllmuster auf solid setzen *)
  551.   IF Bitplanes > 1
  552.   THEN
  553.     box := actBox^[Infoslid].obSpec.Box;
  554.     EXCL(box.flags,0);
  555.     EXCL(box.flags,2);
  556.     EXCL(box.flags,3);
  557.     INCL(box.flags,1);
  558.     INCL(box.flags,4);
  559.     INCL(box.flags,5);
  560.     INCL(box.flags,6);
  561.     actBox^[Infoslid].obSpec.Box := box;
  562.   END;
  563. *)
  564.   mtUtils.SetObjcStringAdr(systemBox, Fredrsc.Systitle, CADR(sysStrOne));
  565.   shell := ShellCall.IsShell();
  566.   IF shell = ShellCall.noShell THEN 
  567.     MagicAES.MenuIenable    (menu, Fredrsc.Callshel, 0);
  568.   END;
  569.   
  570.   WdwManager.EnableIconify (TRUE);
  571.   WdwManager.SetWindowIcon (fredIcon);
  572.   RETURN TRUE
  573. END InitResource;
  574.  
  575. PROCEDURE InitDial (treeIdx: INTEGER; VAR tree: ADDRESS): BOOLEAN;
  576. BEGIN
  577.   tree := MagicAES.RsrcGaddr (MagicAES.RTREE, treeIdx);
  578.   IF ~mtDials.NewDial (tree)
  579.   THEN 
  580.     EditFuncs.OutOfMem();
  581.     RETURN FALSE
  582.   END;
  583.   mtDials.DialCenter (tree, mtDials.CSCREEN, 0, 0, v.r);
  584.   RETURN TRUE
  585. END InitDial;
  586.  
  587. PROCEDURE FormHandle(treeIdx : INTEGER):INTEGER;
  588. VAR exit   : INTEGER;
  589.     form   : ADDRESS;
  590. BEGIN
  591.   (*
  592.   IF ~InitDial (treeIdx, form) THEN RETURN -1 END;
  593.   MagicAES.WindUpdate(MagicAES.BEGUPDATE);
  594.   mtDials.DialForm(form, mtDials.DSTART, v.r, v.r);
  595.   mtDials.DialDraw(form, 0, 200, v.r, FALSE);
  596.   exit := mtDials.DialDo(form, 0);
  597.   exit := INTEGER(BITSET(exit) - {15});
  598.   mtDials.DialForm(form, mtDials.DFINISH, v.r, v.r);
  599.   MagicAES.WindUpdate(MagicAES.ENDUPDATE);
  600.   mtUtils.ExclState(form, exit, MagicAES.SELECTED);
  601.   mtDials.DisposeDial (form);
  602.   *)
  603.   form := MagicAES.RsrcGaddr (MagicAES.RTREE, treeIdx);
  604.   exit := WinDials.WinDialDo (form, 0);
  605.   exit := INTEGER(BITSET(exit) - {15});
  606.   RETURN exit
  607. END FormHandle;
  608.  
  609. PROCEDURE GetItem(dial : ADDRESS; item : INTEGER):BOOLEAN;
  610. BEGIN
  611.   RETURN mtUtils.InState(dial, item, MagicAES.SELECTED);
  612. END GetItem;
  613.  
  614. PROCEDURE SetItem(dial : ADDRESS; item : INTEGER; b : BOOLEAN);
  615. BEGIN
  616.   mtUtils.SetState (dial, item, MagicAES.SELECTED, b);
  617. END SetItem;
  618.  
  619. (*
  620. PROCEDURE DoSearchDialogue(win : INTEGER);
  621.   VAR 
  622.       numStr:           ARRAY [0..7] OF CHAR;
  623.       exit:             INTEGER;
  624.       text:             EditTypes.textPtr;
  625.       len:              LONGCARD;
  626.       allChar,
  627.       oneChar:          CHAR;
  628. BEGIN
  629.   IF CatEdit.IsEditTop (win)
  630.   THEN
  631.     WITH searchOpts DO 
  632.       IF CatEdit.BlockIsMarked (win)
  633.       THEN
  634.         IF CatEdit.GetBlock (win, FALSE, text, len) & (text # NIL)
  635.         THEN
  636.           Strings.Copy (text^, 0, 39, searchStr, v.bool);
  637.           DEALLOCATE (text, 0);
  638.         END;
  639.       END;
  640.       CatEdit.GetWildChars (oneChar, allChar);
  641.       mtUtils.SetObjcString (suchBox, Fredrsc.Sqall, allChar);
  642.       mtUtils.SetObjcString (suchBox, Fredrsc.Sqone, oneChar);
  643.       mtUtils.SetObjcString (suchBox, Fredrsc.Fsuchstr, searchStr);
  644.       exit := FormHandle (Fredrsc.Suchbox);
  645.       IF exit = Fredrsc.Fok
  646.       THEN
  647.         isSet := TRUE;
  648.         (* Strings auslesen *)
  649.         ignoreCase := GetItem (suchBox, Fredrsc.Fcase);
  650.         onlyWord   := GetItem (suchBox, Fredrsc.Fword);
  651.         (* Startposition suchen *)
  652.         IF GetItem (suchBox, Fredrsc.Ffromtop) 
  653.         THEN pos := EditTypes.fromStart; 
  654.         ELSIF GetItem (suchBox, Fredrsc.Ffromcur) 
  655.         THEN pos := EditTypes.fromPos; 
  656.         END;
  657.         direction := EditTypes.forward;
  658.         count := EditTypes.searchOne;
  659.         mtUtils.ObjcString (suchBox, Fredrsc.Fsuchstr, searchStr);
  660.         mtUtils.ObjcString (suchBox, Fredrsc.Sqall, allChar);
  661.         mtUtils.ObjcString (suchBox, Fredrsc.Sqone, oneChar);
  662.         IF (allChar = oneChar) OR (allChar = 0c) OR (oneChar = 0c)
  663.         THEN
  664.           v.int := mtAlerts.Alert (1, wrongWildAlert);
  665.         ELSE
  666.           CatEdit.SetWildChars (oneChar, allChar);
  667.         END;
  668.         v.bool := CatEdit.Search (win, searchStr, pos, direction, count, number, 
  669.                                     ignoreCase, onlyWord, FALSE);
  670.       END;
  671.     END;
  672.   END;
  673. END DoSearchDialogue;
  674. *)
  675.  
  676. PROCEDURE searchButton (tree: ADDRESS; private: ADDRESS; button: INTEGER;
  677.                         mx, my : INTEGER; kstate: BITSET; clicks: INTEGER): BOOLEAN;
  678. VAR   allChar,
  679.       oneChar:          CHAR;
  680. BEGIN
  681.   button := INTEGER(BITSET(button) - {15});
  682.   mtUtils.ExclState(tree, button, MagicAES.SELECTED);
  683.   IF button = Fredrsc.Fok
  684.   THEN
  685.     mtUtils.ObjcString (tree, Fredrsc.Sqall, allChar);
  686.     mtUtils.ObjcString (tree, Fredrsc.Sqone, oneChar);
  687.     IF (allChar = oneChar) OR (allChar = 0c) OR (oneChar = 0c)
  688.     THEN
  689.       v.int := mtAlerts.Alert (1, wrongWildAlert);
  690.       WinDials.WinDialDraw (tree, button, 8, v.r, FALSE);
  691.       RETURN FALSE
  692.     END;
  693.     (* String auslesen *)
  694.     mtUtils.ObjcString (tree, Fredrsc.Fsuchstr, searchOpts.searchStr);
  695.     (* Jetzt Suchstring berprfen, ob nur Wildcards drin sind *)
  696.     IF MagicStrings.Length (searchOpts.searchStr) = 0
  697.     THEN 
  698.       (* Leerer String geht auch *)
  699.       RETURN TRUE
  700.     END;
  701.     (* Jetzt der eigentliche Test *)
  702.     WHILE ((searchOpts.searchStr [0] = allChar) OR (searchOpts.searchStr[0] = oneChar)) & 
  703.           (MagicStrings.Length (searchOpts.searchStr) > 0) DO
  704.       MagicStrings.Delete (searchOpts.searchStr, 0, 1);
  705.       IF MagicStrings.Length (searchOpts.searchStr) = 0
  706.       THEN
  707.         v.int := mtAlerts.Alert (1, noSearchStr);
  708.         WinDials.WinDialDraw (tree, button, 8, v.r, FALSE);
  709.       END;
  710.     END;
  711.     IF MagicStrings.Length (searchOpts.searchStr) > 0 THEN RETURN TRUE; END;
  712.   ELSE
  713.     RETURN TRUE;
  714.   END;
  715.   WinDials.WinDialDraw (tree, button, 8, v.r, FALSE);
  716.   RETURN FALSE;
  717. END searchButton;
  718.  
  719. PROCEDURE searchGetSetValues (tree: ADDRESS; private: ADDRESS; 
  720.                               set: BOOLEAN; exit: INTEGER);
  721. VAR   allChar,
  722.       oneChar:          CHAR;
  723. BEGIN
  724.   IF set
  725.   THEN
  726.     CatEdit.GetWildChars (oneChar, allChar);
  727.     mtUtils.SetObjcString (tree, Fredrsc.Sqall, allChar);
  728.     mtUtils.SetObjcString (tree, Fredrsc.Sqone, oneChar);
  729.     mtUtils.SetObjcString (tree, Fredrsc.Fsuchstr, searchOpts.searchStr);
  730.   ELSE
  731.     exit := INTEGER(BITSET(exit) - {15});
  732.     mtUtils.ExclState(tree, exit, MagicAES.SELECTED);
  733.     IF exit = Fredrsc.Fok
  734.     THEN
  735.       WITH searchOpts DO
  736.         isSet := TRUE;
  737.         (* Strings auslesen *)
  738.         ignoreCase := GetItem (tree, Fredrsc.Fcase);
  739.         onlyWord   := GetItem (tree, Fredrsc.Fword);
  740.         (* Startposition suchen *)
  741.         IF GetItem (tree, Fredrsc.Ffromtop)
  742.         THEN pos := EditTypes.fromStart;
  743.         ELSIF GetItem (tree, Fredrsc.Ffromcur)
  744.         THEN pos := EditTypes.fromPos;
  745.         END;
  746.         (* Anzahl feststellen *)
  747.         count := EditTypes.searchOne;
  748.         (* letzte Parameter *)
  749.         mtUtils.ObjcString (tree, Fredrsc.Sqall, allChar);
  750.         mtUtils.ObjcString (tree, Fredrsc.Sqone, oneChar);
  751.         IF (allChar = oneChar) OR (allChar = 0c) OR (oneChar = 0c)
  752.         THEN
  753.           v.int := mtAlerts.Alert (1, wrongWildAlert);
  754.         ELSE
  755.           CatEdit.SetWildChars (oneChar, allChar);
  756.         END;
  757.         mtUtils.ObjcString (tree, Fredrsc.Fsuchstr, searchStr);
  758.         IF CatEdit.IsEditTop (theSearchWdw)
  759.         THEN
  760.           doIt := TRUE;
  761.           (*
  762.           v.bool := CatEdit.Search (theSearchWdw, searchStr, pos, direction, count, 1,
  763.                                     ignoreCase, onlyWord, FALSE);
  764.           *)
  765.         END;
  766.       END;
  767.     END;
  768.   END;
  769. END searchGetSetValues;
  770.  
  771. PROCEDURE DoSearchDialogue (win: INTEGER);
  772. VAR   form:        mtUtils.tObjcTree;
  773. BEGIN
  774.   form := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Suchbox);
  775.   IF CatEdit.IsEditTop (win)
  776.   THEN
  777.     searchOpts.theSearchWdw := win;
  778.     searchOpts.doIt := FALSE;
  779.     IF ~WinDials.OpenWinDial (form, TRUE, 
  780.                               searchGetSetValues,
  781.                               searchGetSetValues,
  782.                               searchButton,
  783.                               WinDials.defDraw,
  784.                               "",
  785.                               NIL)
  786.     THEN
  787.       noWinDialAlert();
  788.       RETURN
  789.     END;
  790.     WinDials.WinDialHandleEvents();
  791.     WITH searchOpts DO
  792.       IF doIt 
  793.       THEN
  794.         WdwManager.HandlePendingEvents ();
  795.         v.bool := CatEdit.Search (theSearchWdw, searchStr, pos, direction, count, 1,
  796.                                   ignoreCase, onlyWord, FALSE);
  797.       END;
  798.     END;
  799.   END;
  800. END DoSearchDialogue;
  801.  
  802. PROCEDURE SearchAgain (wdw : INTEGER; kstate: BITSET);
  803.   VAR sDir: EditTypes.searchDir;BEGIN
  804.   IF CatEdit.IsEditTop (wdw)
  805.   THEN
  806.     WITH searchOpts DO 
  807.       pos := EditTypes.fromPos;
  808.       IF CatGlobal.WithShift (kstate)
  809.       THEN
  810.         IF direction = EditTypes.forward 
  811.         THEN 
  812.           sDir := EditTypes.backward 
  813.         ELSE
  814.           sDir := EditTypes.forward 
  815.         END;
  816.       ELSE
  817.         sDir := direction;
  818.       END;
  819.       v.bool := CatEdit.Search (wdw, searchStr, pos, sDir, count, number, 
  820.                                 ignoreCase, onlyWord, TRUE);
  821.     END;
  822.   END;
  823. END SearchAgain;
  824.  
  825. PROCEDURE SearchBlock (wdw: INTEGER; kstate: BITSET);
  826.   VAR 
  827.       text:             EditTypes.textPtr;
  828.       len:              LONGCARD;
  829. BEGIN
  830.   IF CatEdit.IsEditTop (wdw)
  831.   THEN
  832.     WITH searchOpts DO 
  833.       IF ~CatEdit.BlockIsMarked (wdw)
  834.       THEN
  835.         CatEdit.MarkWord (wdw);
  836.       END;
  837.       IF CatEdit.BlockIsMarked (wdw)
  838.       THEN
  839.         IF CatEdit.GetBlock (wdw, FALSE, FALSE, text, len) & (text # NIL)
  840.         THEN
  841.           Strings.Copy (text^, 0, 39, searchStr, v.bool);
  842.           DEALLOCATE (text, 0);
  843.         END;
  844.       ELSE
  845.         RETURN
  846.       END;
  847.       isSet := TRUE;
  848.       IF CatGlobal.WithShift (kstate)
  849.       THEN
  850.         pos := EditTypes.fromStart;
  851.       ELSE
  852.         pos := EditTypes.fromPos;
  853.       END;
  854.       direction := EditTypes.forward;
  855.       count := EditTypes.searchOne;
  856.       onlyWord := FALSE;
  857.       v.bool := CatEdit.Search (wdw, searchStr, pos, direction, count, number, 
  858.                                     ignoreCase, onlyWord, FALSE);
  859.     END;
  860.   END;
  861. END SearchBlock;
  862.  
  863. PROCEDURE replaceButton (tree: ADDRESS; private: ADDRESS; button: INTEGER;
  864.                         mx, my : INTEGER; kstate: BITSET; clicks: INTEGER): BOOLEAN;
  865. VAR   allChar,
  866.       oneChar:          CHAR;
  867. BEGIN
  868.   button := INTEGER(BITSET(button) - {15});
  869.   CASE button OF
  870.     Fredrsc.Sgesamt,
  871.     Fredrsc.Seinmal  : mtUtils.SetState (tree, Fredrsc.Scount, MagicAES.DISABLED, TRUE); 
  872.                        mtUtils.SetFlag (tree, Fredrsc.Scount, MagicAES.EDITABLE, FALSE);
  873.                        mtDials.DialDraw (tree, Fredrsc.Scount, 0, v.r, FALSE);
  874.                        RETURN FALSE; |
  875.     Fredrsc.Snmal    : mtUtils.SetState (tree, Fredrsc.Scount, MagicAES.DISABLED, FALSE);
  876.                        mtUtils.SetFlag (tree, Fredrsc.Scount, MagicAES.EDITABLE, TRUE);
  877.                        mtDials.DialDraw (tree, Fredrsc.Scount, 0, v.r, FALSE);
  878.                        RETURN FALSE; |
  879.     Fredrsc.Srok, 
  880.     Fredrsc.Srquit   : mtUtils.ExclState(tree, button, MagicAES.SELECTED);
  881.                        IF button = Fredrsc.Srok
  882.                        THEN
  883.                          mtUtils.ObjcString (tree, Fredrsc.Srqall, allChar);
  884.                          mtUtils.ObjcString (tree, Fredrsc.Srqone, oneChar);
  885.                          IF (allChar = oneChar) OR (allChar = 0c) OR (oneChar = 0c)
  886.                          THEN
  887.                            v.int := mtAlerts.Alert (1, wrongWildAlert);
  888.                            WinDials.WinDialDraw (tree, button, 8, v.r, FALSE);
  889.                            RETURN FALSE
  890.                          END;
  891.                          (* String auslesen *)
  892.                          mtUtils.ObjcString (tree, Fredrsc.Ssuchstr, replaceOpts.searchStr);
  893.                          (* Jetzt Suchstring berprfen, ob nur Wildcards drin sind *)
  894.                          IF MagicStrings.Length (replaceOpts.searchStr) = 0
  895.                          THEN 
  896.                            (* Leerer String geht auch *)
  897.                            RETURN TRUE
  898.                          END;
  899.                          (* Jetzt der eigentliche Test *)
  900.                          WHILE ((replaceOpts.searchStr [0] = allChar) OR (replaceOpts.searchStr[0] = oneChar)) & 
  901.                                (MagicStrings.Length (replaceOpts.searchStr) > 0) DO
  902.                            MagicStrings.Delete (replaceOpts.searchStr, 0, 1);
  903.                            IF MagicStrings.Length (replaceOpts.searchStr) = 0
  904.                            THEN
  905.                              v.int := mtAlerts.Alert (1, noSearchStr);
  906.                              WinDials.WinDialDraw (tree, button, 8, v.r, FALSE);
  907.                            END;
  908.                          END;
  909.                          IF MagicStrings.Length (replaceOpts.searchStr) > 0 THEN RETURN TRUE; END;
  910.                        ELSE
  911.                          RETURN TRUE;
  912.                        END;
  913.                        WinDials.WinDialDraw (tree, button, 8, v.r, FALSE);
  914.   ELSE
  915.   END;  
  916.   RETURN FALSE;
  917. END replaceButton;
  918.  
  919. PROCEDURE replaceGetSetValues (tree: ADDRESS; private: ADDRESS; 
  920.                               set: BOOLEAN; exit: INTEGER);
  921. VAR   allChar,
  922.       oneChar:          CHAR;
  923.       numStr:           ARRAY [0..7] OF CHAR;
  924.       text:             EditTypes.textPtr;
  925.       len:              LONGCARD;
  926. BEGIN
  927.   IF set
  928.   THEN
  929.     WITH replaceOpts DO 
  930.       IF CatEdit.BlockIsMarked (theSearchWdw)
  931.       THEN
  932.         IF CatEdit.GetBlock (theSearchWdw, FALSE, FALSE, text, len) & (text # NIL)
  933.         THEN
  934.           Strings.Copy (text^, 0, 39, searchStr, v.bool);
  935.           DEALLOCATE (text, 0);
  936.         END;
  937.       END;
  938.       CatEdit.GetWildChars (oneChar, allChar);
  939.       mtUtils.SetObjcString (tree, Fredrsc.Srqall, allChar);
  940.       mtUtils.SetObjcString (tree, Fredrsc.Srqone, oneChar);
  941.       mtUtils.SetObjcString (tree, Fredrsc.Ssuchstr, searchStr);
  942.       mtUtils.SetObjcString (tree, Fredrsc.Sreplstr, replaceStr);
  943.       IF GetItem (tree, Fredrsc.Snmal)
  944.       THEN
  945.         mtUtils.SetState (tree, Fredrsc.Scount, MagicAES.DISABLED, FALSE);
  946.         mtUtils.SetFlag (tree, Fredrsc.Scount, MagicAES.EDITABLE, TRUE);
  947.       ELSE
  948.         mtUtils.SetState (tree, Fredrsc.Scount, MagicAES.DISABLED, TRUE);
  949.         mtUtils.SetFlag (tree, Fredrsc.Scount, MagicAES.EDITABLE, FALSE);
  950.       END;
  951.     END;
  952.   ELSE
  953.     exit := INTEGER(BITSET(exit) - {15});
  954.     mtUtils.ExclState(tree, exit, MagicAES.SELECTED);
  955.     IF exit = Fredrsc.Srok
  956.     THEN
  957.       WITH replaceOpts DO
  958.         isSet := TRUE;
  959.         (* Strings auslesen *)
  960.         ignoreCase := GetItem (tree, Fredrsc.Scase);
  961.         onlyWord   := GetItem (tree, Fredrsc.Sword);
  962.         (* Startposition suchen *)
  963.         IF GetItem (tree, Fredrsc.Sfromtop) 
  964.         THEN 
  965.           pos := EditTypes.fromStart; 
  966.         ELSIF GetItem (tree, Fredrsc.Sfromcur) 
  967.         THEN 
  968.           pos := EditTypes.fromPos; 
  969.         END;
  970.  
  971.         (* Suchrichtung feststellen *)
  972.         direction := EditTypes.forward;
  973.         (* Anzahl feststellen *)
  974.         IF GetItem (tree, Fredrsc.Seinmal) 
  975.         THEN 
  976.           count := EditTypes.searchOne;
  977.         ELSIF GetItem (tree, Fredrsc.Sgesamt)
  978.         THEN 
  979.           count := EditTypes.searchAll
  980.         ELSE
  981.           count := EditTypes.searchNum;
  982.           mtUtils.ObjcString (tree, Fredrsc.Scount, numStr);
  983.           v.card := 0;
  984.           number := StrConv.StrToInt (numStr, v.card, v.bool);
  985.         END;
  986.         (* letzte Parameter *)
  987.         askBack := GetItem (tree, Fredrsc.Saskback);
  988.         (* Jetzt noch feststellen, ob Suchen oder Ersetzen *)
  989.         mtUtils.ObjcString (tree, Fredrsc.Ssuchstr, searchStr);
  990.         mtUtils.ObjcString (tree, Fredrsc.Sreplstr, replaceStr);
  991.         mtUtils.ObjcString (tree, Fredrsc.Srqall, allChar);
  992.         mtUtils.ObjcString (tree, Fredrsc.Srqone, oneChar);
  993.         IF (allChar = oneChar) OR (allChar = 0c) OR (oneChar = 0c)
  994.         THEN
  995.           v.int := mtAlerts.Alert (1, wrongWildAlert);
  996.         ELSE
  997.           CatEdit.SetWildChars (oneChar, allChar);
  998.         END;
  999.         IF CatEdit.CheckWildAssign (searchStr, replaceStr)
  1000.         THEN
  1001.           doIt := TRUE;
  1002.           (*
  1003.           v.bool := CatEdit.SearchAndReplace (replaceOpts.theSearchWdw, searchStr, replaceStr, pos, direction, 
  1004.                                     count, number, ignoreCase, onlyWord, 
  1005.                                     askBack, FALSE);
  1006.           *)
  1007.         ELSE
  1008.           v.int := mtAlerts.Alert (1, wrongWildReplace);
  1009.         END;
  1010.       END;
  1011.     END;
  1012.   END;
  1013. END replaceGetSetValues;
  1014.  
  1015. PROCEDURE DoReplaceDialogue (win: INTEGER);
  1016. VAR   form:        mtUtils.tObjcTree;
  1017. BEGIN
  1018.   form := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Ersetzbx);
  1019.   IF CatEdit.IsEditTop (win)
  1020.   THEN
  1021.     replaceOpts.theSearchWdw := win;
  1022.     replaceOpts.doIt := FALSE;
  1023.     IF ~WinDials.OpenWinDial (form, TRUE, 
  1024.                               replaceGetSetValues,
  1025.                               replaceGetSetValues,
  1026.                               replaceButton,
  1027.                               WinDials.defDraw,
  1028.                               "",
  1029.                               NIL)
  1030.     THEN
  1031.       noWinDialAlert();
  1032.       RETURN
  1033.     END;
  1034.     WinDials.WinDialHandleEvents();
  1035.     WITH replaceOpts DO
  1036.       IF doIt 
  1037.       THEN
  1038.         WdwManager.HandlePendingEvents ();
  1039.         v.bool := CatEdit.SearchAndReplace (theSearchWdw, searchStr, replaceStr, pos, direction, 
  1040.                                             count, number, ignoreCase, onlyWord, 
  1041.                                             askBack, FALSE);
  1042.       END;
  1043.     END;
  1044.   END;
  1045. END DoReplaceDialogue;
  1046.  
  1047. (*
  1048. PROCEDURE DoReplaceDialogue(win : INTEGER);
  1049.   VAR 
  1050.       numStr:           ARRAY [0..7] OF CHAR;
  1051.       exit:             INTEGER;
  1052.       text:             EditTypes.textPtr;
  1053.       len:              LONGCARD;
  1054.       ersetzBox:        ADDRESS;
  1055.       allChar,
  1056.       oneChar:          CHAR;
  1057. BEGIN
  1058.   IF CatEdit.IsEditTop (win)
  1059.   THEN
  1060.     IF ~InitDial (Fredrsc.Ersetzbx, ersetzBox) THEN
  1061.       RETURN 
  1062.     END;
  1063.     WITH replaceOpts DO 
  1064.       IF CatEdit.BlockIsMarked (win)
  1065.       THEN
  1066.         IF CatEdit.GetBlock (win, FALSE, text, len) & (text # NIL)
  1067.         THEN
  1068.           Strings.Copy (text^, 0, 39, searchStr, v.bool);
  1069.           DEALLOCATE (text, 0);
  1070.         END;
  1071.       END;
  1072.       CatEdit.GetWildChars (oneChar, allChar);
  1073.       mtUtils.SetObjcString (ersetzBox, Fredrsc.Srqall, allChar);
  1074.       mtUtils.SetObjcString (ersetzBox, Fredrsc.Srqone, oneChar);
  1075.       mtUtils.SetObjcString (ersetzBox, Fredrsc.Ssuchstr, searchStr);
  1076.       mtUtils.SetObjcString (ersetzBox, Fredrsc.Sreplstr, replaceStr);
  1077.       IF GetItem (ersetzBox, Fredrsc.Snmal)
  1078.       THEN
  1079.         mtUtils.SetState (ersetzBox, Fredrsc.Scount, MagicAES.DISABLED, FALSE);
  1080.         mtUtils.SetFlag (ersetzBox, Fredrsc.Scount, MagicAES.EDITABLE, TRUE);
  1081.       ELSE
  1082.         mtUtils.SetState (ersetzBox, Fredrsc.Scount, MagicAES.DISABLED, TRUE);
  1083.         mtUtils.SetFlag (ersetzBox, Fredrsc.Scount, MagicAES.EDITABLE, FALSE);
  1084.       END;
  1085.       MagicAES.WindUpdate(MagicAES.BEGUPDATE);
  1086.       mtDials.DialForm(ersetzBox, mtDials.DSTART, v.r, v.r);
  1087.       mtDials.DialDraw(ersetzBox, 0,200, v.r, FALSE);
  1088.       LOOP
  1089.         exit := mtDials.DialDo(ersetzBox, 0);
  1090.         exit := INTEGER(BITSET(exit) - {15});
  1091.         CASE exit OF
  1092.           Fredrsc.Sgesamt,
  1093.           Fredrsc.Seinmal   : mtUtils.SetState (ersetzBox, Fredrsc.Scount, MagicAES.DISABLED, TRUE); 
  1094.                               mtUtils.SetFlag (ersetzBox, Fredrsc.Scount, MagicAES.EDITABLE, FALSE);
  1095.                               mtDials.DialDraw (ersetzBox, Fredrsc.Scount, 0, v.r, FALSE);|
  1096.           Fredrsc.Snmal     : mtUtils.SetState (ersetzBox, Fredrsc.Scount, MagicAES.DISABLED, FALSE);
  1097.                               mtUtils.SetFlag (ersetzBox, Fredrsc.Scount, MagicAES.EDITABLE, TRUE);
  1098.                               mtDials.DialDraw (ersetzBox, Fredrsc.Scount, 0, v.r, FALSE);|
  1099.           Fredrsc.Srok,
  1100.           Fredrsc.Srquit   : EXIT |
  1101.         ELSE
  1102.         END;  
  1103.       END;
  1104.       mtDials.DialForm(ersetzBox, mtDials.DFINISH, v.r, v.r);
  1105.       MagicAES.WindUpdate(MagicAES.ENDUPDATE);
  1106.       mtUtils.ExclState(ersetzBox, exit, MagicAES.SELECTED);
  1107.       IF exit = Fredrsc.Srok
  1108.       THEN
  1109.         isSet := TRUE;
  1110.         (* Strings auslesen *)
  1111.         ignoreCase := GetItem (ersetzBox, Fredrsc.Scase);
  1112.         onlyWord   := GetItem (ersetzBox, Fredrsc.Sword);
  1113.         (* Startposition suchen *)
  1114.         IF GetItem (ersetzBox, Fredrsc.Sfromtop) 
  1115.         THEN pos := EditTypes.fromStart; 
  1116.         ELSIF GetItem (ersetzBox, Fredrsc.Sfromcur) 
  1117.         THEN pos := EditTypes.fromPos; 
  1118.         END;
  1119.         (* Suchrichtung feststellen *)
  1120.         direction := EditTypes.forward;
  1121.         (* Anzahl feststellen *)
  1122.         IF GetItem (ersetzBox, Fredrsc.Seinmal) 
  1123.         THEN count := EditTypes.searchOne;
  1124.         ELSIF GetItem (ersetzBox, Fredrsc.Sgesamt)
  1125.         THEN count := EditTypes.searchAll
  1126.         ELSE
  1127.           count := EditTypes.searchNum;
  1128.           mtUtils.ObjcString (ersetzBox, Fredrsc.Scount, numStr);
  1129.           v.card := 0;
  1130.           number := StrConv.StrToInt (numStr, v.card, v.bool);
  1131.         END;
  1132.         (* letzte Parameter *)
  1133.         askBack := GetItem (ersetzBox, Fredrsc.Saskback);
  1134.         (* Jetzt noch feststellen, ob Suchen oder Ersetzen *)
  1135.         mtUtils.ObjcString (ersetzBox, Fredrsc.Ssuchstr, searchStr);
  1136.         mtUtils.ObjcString (ersetzBox, Fredrsc.Sreplstr, replaceStr);
  1137.         mtUtils.ObjcString (ersetzBox, Fredrsc.Srqall, allChar);
  1138.         mtUtils.ObjcString (ersetzBox, Fredrsc.Srqone, oneChar);
  1139.         IF (allChar = oneChar) OR (allChar = 0c) OR (oneChar = 0c)
  1140.         THEN
  1141.           v.int := mtAlerts.Alert (1, wrongWildAlert);
  1142.         ELSE
  1143.           CatEdit.SetWildChars (oneChar, allChar);
  1144.         END;
  1145.         IF CatEdit.CheckWildAssign (searchStr, replaceStr)
  1146.         THEN
  1147.           v.bool := CatEdit.SearchAndReplace (win, searchStr, replaceStr, pos, direction, 
  1148.                                     count, number, ignoreCase, onlyWord, 
  1149.                                     askBack, FALSE);
  1150.         ELSE
  1151.           v.int := mtAlerts.Alert (1, wrongWildReplace);
  1152.         END;
  1153.       END;
  1154.     END;
  1155.     mtDials.DisposeDial (ersetzBox);
  1156.   END;
  1157. END DoReplaceDialogue;
  1158. *)
  1159.  
  1160. PROCEDURE ReplaceAgain (wdw : INTEGER; kstate : BITSET);
  1161.   VAR sDir: EditTypes.searchDir;BEGIN
  1162.   IF CatEdit.IsEditTop (wdw)
  1163.   THEN
  1164.     WITH replaceOpts DO 
  1165.       pos := EditTypes.fromPos;
  1166.       IF CatGlobal.WithShift (kstate)
  1167.       THEN
  1168.         IF direction = EditTypes.forward 
  1169.         THEN 
  1170.           sDir := EditTypes.backward 
  1171.         ELSE
  1172.           sDir := EditTypes.forward 
  1173.         END;
  1174.       ELSE
  1175.         sDir := direction;
  1176.       END;
  1177.       v.bool := CatEdit.SearchAndReplace (wdw, searchStr, replaceStr, pos, sDir, 
  1178.                                 count, number, ignoreCase, onlyWord, 
  1179.                                 askBack, TRUE);
  1180.     END;
  1181.   END;
  1182. END ReplaceAgain;
  1183.  
  1184.   TYPE Trick =  POINTER TO RECORD
  1185.                   CASE : BOOLEAN OF
  1186.                     TRUE:  wert: INTEGER;|
  1187.                     FALSE: hi: CHAR;
  1188.                            lo: CHAR;|
  1189.                   END;
  1190.                  END;
  1191.  
  1192. PROCEDURE SetXString (tree  : ADDRESS; obj: INTEGER;
  1193.                       sTree : ADDRESS; idx: INTEGER);
  1194.   VAR t       : Trick;
  1195.       selStr  : ARRAY [0..40] OF CHAR;
  1196. BEGIN
  1197.   mtUtils.ObjcString (sTree, idx+1, selStr);
  1198.   mtUtils.SetObjcString (tree, obj, selStr);
  1199. END SetXString;
  1200.  
  1201. PROCEDURE SetXState (tree : ADDRESS; obj: INTEGER; xState : INTEGER);
  1202.   VAR t : Trick;
  1203.       tr: mtUtils.tObjcTree;
  1204. BEGIN
  1205.   tr := tree;
  1206.   t := ADR (tr^[obj].obState);
  1207.   t^.hi := CHR(xState);
  1208. END SetXState;
  1209.  
  1210. PROCEDURE GetXState (tree : ADDRESS; obj: INTEGER) : INTEGER;
  1211.   VAR t : Trick;
  1212.       tr: mtUtils.tObjcTree;
  1213. BEGIN
  1214.   tr := tree;
  1215.   t := ADR (tr^[obj].obState);
  1216.   RETURN INTEGER(ORD (t^.hi));
  1217. END GetXState;
  1218.  
  1219. PROCEDURE SetIntStr (tree: ADDRESS; obj: INTEGER; val : INTEGER);
  1220.   VAR str : ARRAY [0..79] OF CHAR;
  1221. BEGIN
  1222.   MagicConvert.IntToStr (val, 0, str);
  1223.   mtUtils.SetObjcString (tree, obj, str);
  1224. END SetIntStr;
  1225.  
  1226. PROCEDURE GetIntStr (tree: ADDRESS; obj: INTEGER; VAR val : INTEGER);
  1227.   VAR str : ARRAY [0..79] OF CHAR;
  1228.       lval: LONGINT;
  1229. BEGIN
  1230.   mtUtils.ObjcString (tree, obj, str);
  1231.   lval := MagicConvert.StrToLInt (str);
  1232.   IF (lval > MAX(INTEGER)) THEN val := MAX(INTEGER)
  1233.   ELSIF (lval < MIN(INTEGER)) THEN val := MIN (INTEGER)
  1234.   ELSE
  1235.     val := SHORT (lval)
  1236.   END;
  1237. END GetIntStr;
  1238.  
  1239. (*
  1240. PROCEDURE doFilter (VAR filterNumber: INTEGER; VAR cmd: ARRAY OF CHAR): BOOLEAN;
  1241.   VAR but       : INTEGER;
  1242.       filtSel   : mtUtils.tObjcTree;
  1243.       filterBox : mtUtils.tObjcTree;
  1244.       t         : Trick;
  1245.       i,
  1246.       x, y, 
  1247.       select    : INTEGER;
  1248.       varname   : CatTypes.String127;
  1249. BEGIN
  1250.   filtSel := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Filtsel);
  1251.   IF ~InitDial (Fredrsc.Filtbox, filterBox)
  1252.   THEN
  1253.     RETURN FALSE
  1254.   END;
  1255.   mtUtils.SetObjcString (filterBox, Fredrsc.Fbcomm, "");
  1256.   FOR i := 7 TO 10 DO
  1257.     MagicStrings.Assign (cFilter, varname);
  1258.     MagicStrings.Append (StrConv.IntToStr (i-6, 0), varname);
  1259.     IF ConfVars.GetConfigString (varname, cmd)
  1260.     THEN
  1261.       IF i - 1 = filterNumber
  1262.       THEN
  1263.         (* String setzen *)
  1264.         mtUtils.SetObjcString (filterBox, Fredrsc.Fbcomm, cmd);
  1265.       END;
  1266.       MagicStrings.Insert (' ', cmd, 0);
  1267.     ELSE
  1268.       (* Extern X anlegen *)
  1269.       MagicStrings.Assign (' Extern ', cmd);
  1270.       MagicStrings.Append (StrConv.IntToStr (i-6, 0), cmd);
  1271.     END;
  1272.     mtUtils.SetObjcString (filtSel, i, cmd);
  1273.   END;
  1274.   IF shell = ShellCall.noShell
  1275.   THEN
  1276.     FOR i := 7 TO 10 DO
  1277.       mtUtils.InclState (filtSel, i, MagicAES.DISABLED);
  1278.       mtUtils.ExclFlag (filtSel, i, MagicAES.SELECTABLE);
  1279.     END;
  1280.   END;
  1281.   (* vorbereiten *)
  1282.   SetXState (filterBox, Fredrsc.Fbfilt1, filterNumber);
  1283.   SetXString (filterBox, Fredrsc.Fbfilt1, filtSel, filterNumber);
  1284.   mtDials.DialForm (filterBox, mtDials.DSTART, v.r, v.r);
  1285.   mtDials.DialDraw (filterBox, 0, 99, v.r, FALSE);
  1286.   LOOP
  1287.     but := mtDials.DialDo (filterBox, 0);
  1288.     but := INTEGER(BITSET(but) - {15});
  1289.     CASE but OF
  1290.       Fredrsc.Fbok,
  1291.       Fredrsc.Fbquit : EXIT |
  1292.       (*
  1293.       Fredrsc.Fbhelp : 
  1294.         mtDials.DialForm (filterBox, mtDials.DDISABLE, v.r, v.r);
  1295.         CatHelp.DoHelp (CatHelp.filter);
  1296.         mtDials.DialForm (filterBox, mtDials.DENABLE, v.r, v.r); 
  1297.         mtUtils.ExclState (filterBox, but, MagicAES.SELECTED);
  1298.         mtDials.DialDraw (filterBox, but, 1, v.r, FALSE); |
  1299.       *)
  1300.       Fredrsc.Fbfilt0,
  1301.       Fredrsc.Fbfilt1:
  1302.         IF but = Fredrsc.Fbfilt0 THEN but:= Fredrsc.Fbfilt1 END;
  1303.         MagicAES.ObjcOffset (filterBox, but, x, y);
  1304.         t := ADR (filterBox^[but].obState);
  1305.         select := mtPopups.TreePopup (filtSel, x, y, ORD(t^.hi))-1;
  1306.         IF (shell = ShellCall.noShell) & (select > 5) THEN select := -1 END;
  1307.         IF select >= 0 THEN
  1308.           t^.hi := CHR(select);
  1309.           SetXString (filterBox, but, filtSel, select);
  1310.           IF select > 5
  1311.           THEN
  1312.             MagicStrings.Assign (cFilter, varname);
  1313.             MagicStrings.Append (StrConv.IntToStr (select-5, 0), varname);
  1314.             ConfVars.GetConfDefStr (varname, cmd, "");
  1315.             mtUtils.SetObjcString (filterBox, Fredrsc.Fbcomm, cmd);
  1316.           ELSE
  1317.             mtUtils.SetObjcString (filterBox, Fredrsc.Fbcomm, '');
  1318.           END;
  1319.           mtDials.DialDraw (filterBox, Fredrsc.Fbcomm, 0, v.r, FALSE);
  1320.           mtDials.DialDraw (filterBox, but, 0, v.r, FALSE);
  1321.         END; |
  1322.       Fredrsc.Fbfilt2:
  1323.         t := ADR (filterBox^[but-1].obState);
  1324.         IF shell # ShellCall.noShell
  1325.         THEN
  1326.           t^.hi := CHR((ORD(t^.hi)+1) MOD 10);
  1327.         ELSE
  1328.           t^.hi := CHR((ORD(t^.hi)+1) MOD 6);
  1329.         END;
  1330.         select := ORD (t^.hi);
  1331.         SetXString (filterBox, but-1, filtSel, select);
  1332.         IF select > 5
  1333.         THEN
  1334.           MagicStrings.Assign (cFilter, varname);
  1335.           MagicStrings.Append (StrConv.IntToStr (select-5, 0), varname);
  1336.           ConfVars.GetConfDefStr (varname, cmd, "");
  1337.           mtUtils.SetObjcString (filterBox, Fredrsc.Fbcomm, cmd);
  1338.         ELSE
  1339.           mtUtils.SetObjcString (filterBox, Fredrsc.Fbcomm, '');
  1340.         END;
  1341.         mtDials.DialDraw (filterBox, Fredrsc.Fbcomm, 0, v.r, FALSE);
  1342.         mtDials.DialDraw (filterBox, but-1, 0, v.r, FALSE); |
  1343.     END;
  1344.   END; (* LOOP *)
  1345.   IF but = Fredrsc.Fbok
  1346.   THEN
  1347.     filterNumber := GetXState (filterBox, Fredrsc.Fbfilt1);
  1348.     IF filterNumber > 5
  1349.     THEN
  1350.       (* String auslesen *)
  1351.       mtUtils.ObjcString (filterBox, Fredrsc.Fbcomm, cmd);
  1352.       MagicStrings.Assign (cFilter, varname);
  1353.       MagicStrings.Append (StrConv.IntToStr (filterNumber-5, 0), varname);
  1354.       v.bool := ConfVars.SetConfigString (varname, cmd);
  1355.     END;
  1356.   END; 
  1357.   mtUtils.ExclState (filterBox, but, MagicAES.SELECTED);
  1358.   mtDials.DialForm (filterBox, mtDials.DFINISH, v.r, v.r);
  1359.   mtDials.DisposeDial (filterBox);
  1360.   RETURN but = Fredrsc.Fbok;
  1361. END doFilter;
  1362. *)
  1363.  
  1364. PROCEDURE buildVarName (REF name: ARRAY OF CHAR; number: INTEGER; VAR newName: ARRAY OF CHAR);
  1365. BEGIN
  1366.   Strings.Assign (name, newName, v.bool);
  1367.   Strings.Append (StrConv.IntToStr (number, 0), newName, v.bool);
  1368. END buildVarName;
  1369.  
  1370.   CONST lowExtern = 8;
  1371.         highExtern = 15;
  1372.         filtMax    = 15;
  1373.         filtExt    = 8;
  1374.  
  1375. PROCEDURE BuildFilterPopup (VAR filterNumber: INTEGER; VAR filtSel : mtUtils.tObjcTree; 
  1376.                             forDial: BOOLEAN);
  1377.   VAR i         : INTEGER;
  1378.       varname   : CatTypes.String127;
  1379.       cmd       : CatTypes.String127;
  1380.       filterBox : mtUtils.tObjcTree;
  1381.       isDa      : BOOLEAN;
  1382. BEGIN
  1383.   filterBox := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Filtbox);
  1384.   filtSel   := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Filtsel);
  1385.   mtUtils.SetObjcString (filterBox, Fredrsc.Fbcomm, "");
  1386.   FOR i := lowExtern TO highExtern DO
  1387.     buildVarName (cFilter, i-lowExtern+1, varname);
  1388.     isDa := ConfVars.GetConfigString (varname, cmd);
  1389.     IF isDa
  1390.     THEN
  1391.       IF i - 1 = filterNumber
  1392.       THEN
  1393.         (* String setzen *)
  1394.         mtUtils.SetObjcString (filterBox, Fredrsc.Fbcomm, cmd);
  1395.       END;
  1396.       MagicStrings.Insert (' ', cmd, 0);
  1397.     ELSE
  1398.       (* Extern X anlegen *)
  1399.       MagicStrings.Assign (' Extern ', cmd);
  1400.       MagicStrings.Append (StrConv.IntToStr (i-lowExtern+1, 0), cmd);
  1401.     END;
  1402.     mtUtils.SetState (filtSel, i, MagicAES.DISABLED, ~isDa & ~forDial);
  1403.     mtUtils.SetFlag  (filtSel, i, MagicAES.SELECTABLE, isDa OR forDial);
  1404.     mtUtils.SetObjcString (filtSel, i, cmd);
  1405.   END;
  1406.   IF ShellCall.IsShell() = ShellCall.noShell
  1407.   THEN
  1408.     FOR i := lowExtern TO highExtern DO
  1409.       mtUtils.InclState (filtSel, i, MagicAES.DISABLED);
  1410.       mtUtils.ExclFlag (filtSel, i, MagicAES.SELECTABLE);
  1411.     END;
  1412.   END;
  1413. END BuildFilterPopup;
  1414.  
  1415. TYPE    blockInfo   = RECORD
  1416.                         filterNumber    : INTEGER;
  1417.                         cmd             : CatTypes.String255;
  1418.                         exitBut         : INTEGER;
  1419.                         filtSel : mtUtils.tObjcTree;
  1420.                       END;
  1421.         blockInfoPtr = POINTER TO blockInfo;
  1422.         
  1423. PROCEDURE blockButton (obTree: ADDRESS; private: ADDRESS; button: INTEGER;
  1424.                        mx, my : INTEGER; kstate: BITSET; clicks: INTEGER): BOOLEAN;
  1425. VAR infoPtr : blockInfoPtr;
  1426.     but     : INTEGER;
  1427.     t       : Trick;
  1428.     x, y, 
  1429.     select  : INTEGER;
  1430.     varname : CatTypes.String127;
  1431.     tree    : mtUtils.tObjcTree;
  1432. BEGIN
  1433.   infoPtr := private;
  1434.   tree := obTree;
  1435.   but := INTEGER(BITSET(button) - {15});
  1436.   CASE but OF
  1437.     Fredrsc.Fbok,
  1438.     Fredrsc.Fbquit : 
  1439.       mtUtils.ExclState (tree, but, MagicAES.SELECTED);
  1440.       RETURN TRUE; |
  1441.       (*
  1442.     Fredrsc.Fbhelp : 
  1443.       CatHelp.DoHelp (CatHelp.filter);
  1444.       mtUtils.ExclState (tree, but, MagicAES.SELECTED);
  1445.       mtDials.DialDraw (tree, but, 1, v.r, FALSE); |
  1446.       *)
  1447.     Fredrsc.Fbfilt0,
  1448.     Fredrsc.Fbfilt1:
  1449.       but := Fredrsc.Fbfilt1;
  1450.       MagicAES.ObjcOffset (tree, but, x, y);
  1451.       t := ADR (tree^[but].obState);
  1452.       select := mtPopups.TreePopup (infoPtr^.filtSel, x, y, ORD(t^.hi))-1;
  1453.       IF (ShellCall.IsShell() = ShellCall.noShell) & (select >= lowExtern) THEN select := -1 END;
  1454.       IF select >= 0 THEN
  1455.         t^.hi := CHR(select);
  1456.         SetXString (tree, but, infoPtr^.filtSel, select);
  1457.         IF select >= lowExtern-1
  1458.         THEN
  1459.           buildVarName (cFilter, select-lowExtern+2, varname);
  1460.           ConfVars.GetConfDefStr (varname, infoPtr^.cmd, "");
  1461.           mtUtils.SetObjcString (tree, Fredrsc.Fbcomm, infoPtr^.cmd);
  1462.         ELSE
  1463.           mtUtils.SetObjcString (tree, Fredrsc.Fbcomm, '');
  1464.         END;
  1465.         mtDials.DialDraw (tree, Fredrsc.Fbcomm, 0, v.r, FALSE);
  1466.         mtDials.DialDraw (tree, but, 0, v.r, FALSE);
  1467.       END; |
  1468.     Fredrsc.Fbfilt2:
  1469.       t := ADR (tree^[but-1].obState);
  1470.       IF (ShellCall.IsShell() # ShellCall.noShell)
  1471.       THEN
  1472.         t^.hi := CHR((ORD(t^.hi)+1) MOD filtMax);
  1473.       ELSE
  1474.         t^.hi := CHR((ORD(t^.hi)+1) MOD (filtMax - filtExt));
  1475.       END;
  1476.       select := ORD (t^.hi);
  1477.       SetXString (tree, but-1, infoPtr^.filtSel, select);
  1478.       IF select >= lowExtern-1
  1479.       THEN
  1480.         buildVarName (cFilter, select-lowExtern+2, varname);
  1481.         ConfVars.GetConfDefStr (varname, infoPtr^.cmd, "");
  1482.         mtUtils.SetObjcString (tree, Fredrsc.Fbcomm, infoPtr^.cmd);
  1483.       ELSE
  1484.         mtUtils.SetObjcString (tree, Fredrsc.Fbcomm, '');
  1485.       END;
  1486.       mtDials.DialDraw (tree, Fredrsc.Fbcomm, 0, v.r, FALSE);
  1487.       mtDials.DialDraw (tree, but-1, 0, v.r, FALSE); |
  1488.   ELSE
  1489.   END;
  1490.   RETURN FALSE;
  1491. END blockButton;
  1492.  
  1493. PROCEDURE blockGetSetValues (tree: ADDRESS; private: ADDRESS; 
  1494.                              set: BOOLEAN; exit: INTEGER);
  1495. VAR infoPtr : blockInfoPtr;
  1496.     varname : CatTypes.String127;
  1497. BEGIN
  1498.   infoPtr := private;
  1499.   infoPtr^.exitBut := INTEGER(BITSET(exit) - {15});
  1500.   IF set
  1501.   THEN
  1502.     BuildFilterPopup (infoPtr^.filterNumber, infoPtr^.filtSel, TRUE);
  1503.     (* vorbereiten *)
  1504.     SetXState (tree, Fredrsc.Fbfilt1, infoPtr^.filterNumber);
  1505.     SetXString (tree, Fredrsc.Fbfilt1, infoPtr^.filtSel, infoPtr^.filterNumber);
  1506.   ELSE
  1507.     IF infoPtr^.exitBut = Fredrsc.Fbok
  1508.     THEN
  1509.       infoPtr^.filterNumber := GetXState (tree, Fredrsc.Fbfilt1);
  1510.       IF infoPtr^.filterNumber >= lowExtern-1
  1511.       THEN
  1512.         (* String auslesen *)
  1513.         mtUtils.ObjcString (tree, Fredrsc.Fbcomm, infoPtr^.cmd);
  1514.         buildVarName (cFilter, infoPtr^.filterNumber-lowExtern+2, varname);
  1515.         v.bool := ConfVars.SetConfigString (varname, infoPtr^.cmd);
  1516.       END;
  1517.     END; 
  1518.   END;
  1519. END blockGetSetValues;
  1520.  
  1521. PROCEDURE doFilter (VAR filterNumber: INTEGER; VAR cmd: ARRAY OF CHAR): BOOLEAN;
  1522.   VAR filterBox : mtUtils.tObjcTree;
  1523.       infoPtr   : blockInfoPtr;
  1524.       result    : BOOLEAN;
  1525. BEGIN
  1526.   IF filterNumber < 0 THEN filterNumber := 0; END;
  1527.   filterBox := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Filtbox);
  1528.   NEW (infoPtr);
  1529.   IF infoPtr=NIL
  1530.   THEN
  1531.     RETURN FALSE;
  1532.   END;
  1533.   MagicStrings.Assign (cmd, infoPtr^.cmd);
  1534.   infoPtr^.filterNumber := filterNumber;
  1535.   
  1536.   IF ~WinDials.OpenWinDial (filterBox, TRUE, 
  1537.                             blockGetSetValues,
  1538.                             blockGetSetValues,
  1539.                             blockButton,
  1540.                             WinDials.defDraw,
  1541.                             "",
  1542.                             infoPtr)
  1543.   THEN
  1544.     noWinDialAlert();
  1545.     DISPOSE (infoPtr);
  1546.     RETURN FALSE;
  1547.   END;
  1548.   (* Da wir die Ergebnisse brauchen, mssen wir hier die Eventroutine 
  1549.    * aufrufen 
  1550.    *)
  1551.   WinDials.WinDialHandleEvents();
  1552.   
  1553.   filterNumber := infoPtr^.filterNumber;
  1554.   MagicStrings.Assign (infoPtr^.cmd, cmd);
  1555.  
  1556.   result := infoPtr^.exitBut = Fredrsc.Fbok;
  1557.   
  1558.   DISPOSE (infoPtr);
  1559.   
  1560.   RETURN result;
  1561.   
  1562. END doFilter;
  1563.  
  1564. PROCEDURE doPopupFilter (VAR filterNumber: INTEGER; VAR cmd: ARRAY OF CHAR): BOOLEAN;
  1565.   VAR but       : INTEGER;
  1566.       filtSel   : mtUtils.tObjcTree;
  1567.       varname   : CatTypes.String127;
  1568.       x, y      : INTEGER;
  1569.       fNumber   : INTEGER;
  1570. BEGIN
  1571.   IF filterNumber < 0 THEN filterNumber := 0; END;
  1572.   BuildFilterPopup (filterNumber, filtSel, FALSE);
  1573.   MagicAES.GrafMkstate (x, y, v.bset, v.bset);
  1574.   fNumber := mtPopups.TreePopup (filtSel, x, y, 0) - 1;
  1575.   IF fNumber >= 0
  1576.   THEN
  1577.     filterNumber := fNumber;
  1578.   END;
  1579.   IF fNumber >= lowExtern-1
  1580.   THEN
  1581.     (* String auslesen *)
  1582.     buildVarName (cFilter, fNumber-lowExtern+2, varname);
  1583.     IF ConfVars.GetConfigString (varname, cmd)
  1584.     THEN
  1585.       RETURN TRUE;
  1586.     END;
  1587.     RETURN FALSE
  1588.   END;
  1589.   RETURN fNumber >= 0
  1590. END doPopupFilter;
  1591.  
  1592.  
  1593. TYPE    printerInfo = RECORD
  1594.                         cfgFile       : CatTypes.String255;
  1595.                         cfgPath       : CatTypes.pathStrType;
  1596.                         cfgName       : CatTypes.nameStrType;
  1597.                         cfgExt        : CatTypes.extStrType;
  1598.                       END;
  1599.         prInfoPtr   = POINTER TO printerInfo;
  1600.  
  1601. PROCEDURE printerButton (tree: ADDRESS; private: ADDRESS; button: INTEGER;
  1602.                           mx, my : INTEGER; kstate: BITSET; clicks: INTEGER): BOOLEAN;
  1603.   VAR but           : INTEGER;
  1604.       prnConf,
  1605.       prnStyleSel,
  1606.       prnIFSel      : mtUtils.tObjcTree;
  1607.       x, y          : INTEGER;
  1608.       select        : INTEGER;
  1609.       selStr        : ARRAY [0..40] OF CHAR;
  1610.       t             : Trick;
  1611.       res           : BOOLEAN;
  1612.       name          : CatTypes.String127;
  1613.       prInfo        : prInfoPtr;
  1614. BEGIN
  1615.   prInfo := private;
  1616.  
  1617.   prnStyleSel := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Psizebox);
  1618.   prnIFSel    := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Ifbox);
  1619.  
  1620.   prnConf := tree;
  1621.   but := INTEGER(BITSET(button) - {15});
  1622.   CASE but OF
  1623.     Fredrsc.Oprtsiz0,
  1624.     Fredrsc.Oprtsiz1:
  1625.            but := Fredrsc.Oprtsiz1;
  1626.            MagicAES.ObjcOffset (tree, but, x, y);
  1627.            t := ADR (prnConf^[but].obState);
  1628.            select := mtPopups.TreePopup (prnStyleSel, x, y, ORD(t^.hi))-1;
  1629.            IF select >= 0 THEN
  1630.              t^.hi := CHR(select);
  1631.              SetXString (tree, but, prnStyleSel, select);
  1632.              WinDials.WinDialDraw (tree, but, 0, v.r, FALSE);
  1633.            END;|
  1634.     Fredrsc.Oprtsiz2:
  1635.            t := ADR (prnConf^[but-1].obState);
  1636.            t^.hi := CHR((ORD(t^.hi)+1) MOD 3);
  1637.            select := ORD (t^.hi);
  1638.            SetXString (tree, but-1, prnStyleSel, select);
  1639.            WinDials.WinDialDraw (tree, but-1, 0, v.r, FALSE); |
  1640.     Fredrsc.Ointerfc0,
  1641.     Fredrsc.Ointerfc1: 
  1642.            but := Fredrsc.Ointerfc1;
  1643.            MagicAES.ObjcOffset (tree, but, x, y);
  1644.            t := ADR (prnConf^[but].obState);
  1645.            select := mtPopups.TreePopup (prnIFSel, x, y, ORD(t^.hi))-1;
  1646.            IF select >= 0 THEN
  1647.              t^.hi := CHR(select);
  1648.              SetXString (tree, but, prnIFSel, select);
  1649.              WinDials.WinDialDraw (tree, but, 0, v.r, FALSE);
  1650.            END;|
  1651.     Fredrsc.Ointerfc2:
  1652.            t := ADR (prnConf^[but-1].obState);
  1653.            t^.hi := CHR((ORD(t^.hi)+1) MOD 2);
  1654.            select := ORD (t^.hi);
  1655.            SetXString (tree, but-1, prnIFSel, select);
  1656.            WinDials.WinDialDraw (tree, but-1, 0, v.r, FALSE); |
  1657.     Fredrsc.Oselcfg0,
  1658.     Fredrsc.Oselcfg:
  1659.            but := Fredrsc.Oselcfg;
  1660.            res := CatGlobal.FselGet (prInfo^.cfgPath, prInfo^.cfgName, '*.cfg', 'CFG-Datei ausw„hlen', TRUE);
  1661.            IF res & (prInfo^.cfgName[0] # '')
  1662.            THEN
  1663.              MagicStrings.Assign (prInfo^.cfgPath, prInfo^.cfgFile);
  1664.              MagicStrings.Append (prInfo^.cfgName, prInfo^.cfgFile);
  1665.              Printer.LoadCFGFile (prInfo^.cfgFile);
  1666.              IF Printer.Response = Printer.CFGnotFound
  1667.              THEN
  1668.                v.int := mtAlerts.Alert (1, cfgNotFound);
  1669.              ELSIF Printer.Response = Printer.wrongIdent
  1670.              THEN
  1671.                v.int := mtAlerts.Alert (1, noCfgFile);
  1672.              ELSIF Printer.Response = Printer.done
  1673.              THEN
  1674.                Printer.GetPrnName (name);
  1675.                mtUtils.SetObjcString (tree, Fredrsc.Oselcfg, prInfo^.cfgName);
  1676.                mtUtils.SetObjcString (tree, Fredrsc.Printname, name);
  1677.                mtUtils.CalcArea (tree, Fredrsc.Printname, v.r);
  1678.                WinDials.WinDialDraw (tree, 0, 8, v.r, TRUE);
  1679.              END;
  1680.            ELSIF res
  1681.            THEN
  1682.              Printer.FreeCFGFile();
  1683.              MagicStrings.Assign ('', prInfo^.cfgFile);
  1684.              Printer.GetPrnName (name);
  1685.              mtUtils.SetObjcString (tree, Fredrsc.Printname, name);
  1686.              MagicStrings.Assign ('noname.cfg',prInfo^.cfgName);
  1687.              mtUtils.SetObjcString (tree, Fredrsc.Oselcfg, prInfo^.cfgName);
  1688.              mtUtils.CalcArea (tree, Fredrsc.Printname, v.r);
  1689.              WinDials.WinDialDraw (tree, 0, 8, v.r, TRUE);
  1690.            END; 
  1691.            mtUtils.ExclState (tree, but, MagicAES.SELECTED);
  1692.            WinDials.WinDialDraw (tree, but, 0, v.r, FALSE); |  
  1693.     Fredrsc.Prok,
  1694.     Fredrsc.Prcancel: 
  1695.            mtUtils.ExclState (tree, but, MagicAES.SELECTED);
  1696.            RETURN TRUE; |
  1697.   ELSE
  1698.   END;
  1699.   RETURN FALSE;
  1700. END printerButton;
  1701.  
  1702. PROCEDURE printerGetSetValues (tree: ADDRESS; private: ADDRESS; 
  1703.                                set: BOOLEAN; exit: INTEGER);
  1704. VAR prnStyleSel,
  1705.     prnIFSel    : mtUtils.tObjcTree;
  1706.     val         : BOOLEAN;
  1707.     intVal      : INTEGER;
  1708.     name        : ARRAY [0..79] OF CHAR;
  1709.     prInfo      : prInfoPtr;
  1710. BEGIN
  1711.   prInfo := private;
  1712.  
  1713.   prnStyleSel := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Psizebox);
  1714.   prnIFSel    := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Ifbox);
  1715.  
  1716.   IF set
  1717.   THEN (* set *)
  1718.     (* Noch Namen des CFG-Files *)
  1719.     IF ConfVars.GetConfigString (cPrtCfg, prInfo^.cfgFile)
  1720.     THEN
  1721.       mtDir.SplitPath (prInfo^.cfgFile, prInfo^.cfgPath, prInfo^.cfgName, prInfo^.cfgExt);
  1722.     ELSE
  1723.       MagicStrings.Assign ('', prInfo^.cfgFile);
  1724.       MagicStrings.Assign ('noname.cfg', prInfo^.cfgName);
  1725.       MagicStrings.Assign (homePath,prInfo^.cfgPath);
  1726.     END;
  1727.     mtUtils.SetObjcString (tree, Fredrsc.Oselcfg, prInfo^.cfgName);
  1728.  
  1729.     ConfVars.GetConfDefInt (cPrtMargin, intVal, 0);
  1730.     SetIntStr (tree, Fredrsc.Oprleftm, intVal);
  1731.     ConfVars.GetConfDefInt (cPrtLines, intVal, 0);
  1732.     intVal := intVal MOD 10;  (* Maximal 0 bis 9 *)
  1733.     SetIntStr (tree, Fredrsc.Oprlines, intVal);
  1734.     ConfVars.GetConfDefBool (cPrtNlq, val, FALSE);
  1735.     mtUtils.SetState (tree, Fredrsc.Oprnnlq, MagicAES.SELECTED, val);
  1736.     ConfVars.GetConfDefBool (cPrtFF, val, FALSE);
  1737.     mtUtils.SetState (tree, Fredrsc.Oformfeed, MagicAES.SELECTED, val);
  1738.     Printer.GetPrnName (name);
  1739.     mtUtils.SetObjcString (tree, Fredrsc.Printname, name);
  1740.     ConfVars.GetConfDefInt (cPrtPort, intVal, 0);
  1741.     SetXState (tree, Fredrsc.Ointerfc1, ORD(intVal));
  1742.     SetXString (tree, Fredrsc.Ointerfc1, prnIFSel, ORD(intVal));
  1743.     ConfVars.GetConfDefInt (cPrtStyle, intVal, 0);
  1744.     SetXState (tree, Fredrsc.Oprtsiz1, ORD(intVal));
  1745.     SetXString (tree, Fredrsc.Oprtsiz1, prnStyleSel, ORD(intVal));
  1746.   ELSE
  1747.     IF exit = Fredrsc.Prok
  1748.     THEN
  1749.       v.bool := ConfVars.SetConfigInt  (cPrtPort, GetXState (tree, Fredrsc.Ointerfc1));
  1750.       v.bool := ConfVars.SetConfigInt  (cPrtStyle, GetXState (tree, Fredrsc.Oprtsiz1));
  1751.       v.bool := ConfVars.SetConfigBool (cPrtNlq, mtUtils.InState (tree, Fredrsc.Oprnnlq, MagicAES.SELECTED));
  1752.       v.bool := ConfVars.SetConfigBool (cPrtFF, mtUtils.InState (tree, Fredrsc.Oformfeed, MagicAES.SELECTED));
  1753.       GetIntStr (tree, Fredrsc.Oprleftm, intVal);
  1754.       v.bool := ConfVars.SetConfigInt (cPrtMargin, intVal);
  1755.       GetIntStr (tree, Fredrsc.Oprlines, intVal);
  1756.       v.bool := ConfVars.SetConfigInt (cPrtLines, intVal);
  1757.       IF prInfo^.cfgFile[0] # '' THEN v.bool := ConfVars.SetConfigString (cPrtCfg, prInfo^.cfgFile); END;
  1758.     ELSE
  1759.       ConfVars.GetConfDefStr (cPrtCfg, prInfo^.cfgFile, '');
  1760.       IF prInfo^.cfgFile[0] # '' THEN Printer.LoadCFGFile (prInfo^.cfgFile); END;
  1761.     END;
  1762.     DISPOSE (prInfo);
  1763.   END;
  1764. END printerGetSetValues;
  1765.  
  1766. PROCEDURE doPrinter();
  1767. VAR printConf   : mtUtils.tObjcTree;
  1768.       prInfo    : prInfoPtr;
  1769.       
  1770.   
  1771. BEGIN
  1772.   printConf := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Prnconf);
  1773.   
  1774.   NEW (prInfo);
  1775.   IF prInfo = NIL
  1776.   THEN
  1777.     RETURN
  1778.   END;
  1779.   IF ~WinDials.OpenWinDial (printConf, FALSE, 
  1780.                             printerGetSetValues,
  1781.                             printerGetSetValues,
  1782.                             printerButton,
  1783.                             WinDials.defDraw,
  1784.                             "",
  1785.                             prInfo)
  1786.   THEN
  1787.     DISPOSE (prInfo);
  1788.     noWinDialAlert();
  1789.   END;
  1790. END doPrinter;
  1791.  
  1792. (*
  1793. PROCEDURE doPrinter();
  1794. VAR printConf,
  1795.     prnStyleSel,
  1796.     prnIFSel    : mtUtils.tObjcTree;
  1797.  
  1798.  
  1799.   PROCEDURE setGetOpts (setOrGet : BOOLEAN);
  1800.     VAR val : BOOLEAN;
  1801.         intVal : INTEGER;
  1802.         name   : ARRAY [0..79] OF CHAR;
  1803.   BEGIN
  1804.     IF setOrGet
  1805.     THEN (* set *)
  1806.       ConfVars.GetConfDefInt (cPrtMargin, intVal, 0);
  1807.       intVal := intVal MOD 10;  (* Maximal 0 bis 9 *)
  1808.       SetIntStr (printConf, Fredrsc.Oprleftm, intVal);
  1809.       ConfVars.GetConfDefInt (cPrtLines, intVal, 0);
  1810.       intVal := intVal MOD 10;  (* Maximal 0 bis 9 *)
  1811.       SetIntStr (printConf, Fredrsc.Oprlines, intVal);
  1812.       ConfVars.GetConfDefBool (cPrtNlq, val, FALSE);
  1813.       mtUtils.SetState (printConf, Fredrsc.Oprnnlq, MagicAES.SELECTED, val);
  1814.       ConfVars.GetConfDefBool (cPrtFF, val, FALSE);
  1815.       mtUtils.SetState (printConf, Fredrsc.Oformfeed, MagicAES.SELECTED, val);
  1816.       Printer.GetPrnName (name);
  1817.       mtUtils.SetObjcString (printConf, Fredrsc.Printname, name);
  1818.       mtUtils.SetObjcString (printConf, Fredrsc.Oselcfg, '');
  1819.       ConfVars.GetConfDefInt (cPrtPort, intVal, 0);
  1820.       SetXState (printConf, Fredrsc.Ointerfc1, ORD(intVal));
  1821.       SetXString (printConf, Fredrsc.Ointerfc1, prnIFSel, ORD(intVal));
  1822.       ConfVars.GetConfDefInt (cPrtStyle, intVal, 0);
  1823.       SetXState (printConf, Fredrsc.Oprtsiz1, ORD(intVal));
  1824.       SetXString (printConf, Fredrsc.Oprtsiz1, prnStyleSel, ORD(intVal));
  1825.     ELSE
  1826.       v.bool := ConfVars.SetConfigInt  (cPrtPort, GetXState (printConf, Fredrsc.Ointerfc1));
  1827.       v.bool := ConfVars.SetConfigInt  (cPrtStyle, GetXState (printConf, Fredrsc.Oprtsiz1));
  1828.       v.bool := ConfVars.SetConfigBool (cPrtNlq, mtUtils.InState (printConf, Fredrsc.Oprnnlq, MagicAES.SELECTED));
  1829.       v.bool := ConfVars.SetConfigBool (cPrtFF, mtUtils.InState (printConf, Fredrsc.Oformfeed, MagicAES.SELECTED));
  1830.       GetIntStr (printConf, Fredrsc.Oprleftm, intVal);
  1831.       v.bool := ConfVars.SetConfigInt (cPrtMargin, intVal);
  1832.       GetIntStr (printConf, Fredrsc.Oprlines, intVal);
  1833.       v.bool := ConfVars.SetConfigInt (cPrtLines, intVal);
  1834.     END;
  1835.   END setGetOpts;
  1836.        
  1837.   VAR but       : INTEGER;
  1838.       x, y      : INTEGER;
  1839.       select    : INTEGER;
  1840.       selStr    : ARRAY [0..40] OF CHAR;
  1841.       t         : Trick;
  1842.       cfgFile   : CatTypes.String255;
  1843.       cfgPath   : CatTypes.pathStrType;
  1844.       cfgName   : CatTypes.nameStrType;
  1845.       cfgExt    : CatTypes.extStrType;
  1846.       prnConf   : mtUtils.tObjcTree;
  1847.       res       : BOOLEAN;
  1848.       name      : CatTypes.String127;
  1849.       
  1850.   
  1851. BEGIN
  1852.   prnStyleSel := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Psizebox);
  1853.   prnIFSel    := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Ifbox);
  1854.   IF ~InitDial (Fredrsc.Prnconf, printConf) THEN RETURN END; 
  1855.   prnConf := printConf;
  1856.   setGetOpts (TRUE);
  1857.   (* Noch Namen des CFG-Files *)
  1858.   IF ConfVars.GetConfigString (cPrtCfg, cfgFile)
  1859.   THEN
  1860.     mtDir.SplitPath (cfgFile, cfgPath, cfgName, cfgExt);
  1861.   ELSE
  1862.     MagicStrings.Assign ('', cfgFile);
  1863.     MagicStrings.Assign ('noname.cfg',cfgName);
  1864.     MagicStrings.Assign (homePath,cfgPath);
  1865.   END;
  1866.   mtUtils.SetObjcString (printConf, Fredrsc.Oselcfg, cfgName);
  1867.   MagicAES.WindUpdate (MagicAES.BEGMCTRL);
  1868.   mtDials.DialForm (printConf, mtDials.DSTART, v.r, v.r);
  1869.   mtDials.DialDraw (printConf, 0, 99, v.r, FALSE);
  1870.   LOOP
  1871.    but := mtDials.DialDo (printConf, 0);
  1872.    but := INTEGER(BITSET(but) - {15});
  1873.    CASE but OF
  1874.     Fredrsc.Oprtsiz0,
  1875.     Fredrsc.Oprtsiz1:
  1876.            but := Fredrsc.Oprtsiz1;
  1877.            MagicAES.ObjcOffset (printConf, but, x, y);
  1878.            t := ADR (prnConf^[but].obState);
  1879.            select := mtPopups.TreePopup (prnStyleSel, x, y, ORD(t^.hi))-1;
  1880.            IF select >= 0 THEN
  1881.              t^.hi := CHR(select);
  1882.              SetXString (printConf, but, prnStyleSel, select);
  1883.              mtDials.DialDraw (printConf, but, 0, v.r, FALSE);
  1884.            END;|
  1885.     Fredrsc.Oprtsiz2:
  1886.            t := ADR (prnConf^[but-1].obState);
  1887.            t^.hi := CHR((ORD(t^.hi)+1) MOD 3);
  1888.            select := ORD (t^.hi);
  1889.            SetXString (printConf, but-1, prnStyleSel, select);
  1890.            mtDials.DialDraw (printConf, but-1, 0, v.r, FALSE); |
  1891.     Fredrsc.Ointerfc0,
  1892.     Fredrsc.Ointerfc1: 
  1893.            but := Fredrsc.Ointerfc1;
  1894.            MagicAES.ObjcOffset (printConf, but, x, y);
  1895.            t := ADR (prnConf^[but].obState);
  1896.            select := mtPopups.TreePopup (prnIFSel, x, y, ORD(t^.hi))-1;
  1897.            IF select >= 0 THEN
  1898.              t^.hi := CHR(select);
  1899.              SetXString (printConf, but, prnIFSel, select);
  1900.              mtDials.DialDraw (printConf, but, 0, v.r, FALSE);
  1901.            END;|
  1902.     Fredrsc.Ointerfc2:
  1903.            t := ADR (prnConf^[but-1].obState);
  1904.            t^.hi := CHR((ORD(t^.hi)+1) MOD 2);
  1905.            select := ORD (t^.hi);
  1906.            SetXString (printConf, but-1, prnIFSel, select);
  1907.            (*
  1908.            mtUtils.ObjcString (prnIFSel, select+1, selStr);
  1909.            mtUtils.SetObjcString (printConf, but-1, selStr);
  1910.            *)
  1911.            mtDials.DialDraw (printConf, but-1, 0, v.r, FALSE); |
  1912.     Fredrsc.Oselcfg0,
  1913.     Fredrsc.Oselcfg:
  1914.            but := Fredrsc.Oselcfg;
  1915.            mtDials.DialForm (printConf, mtDials.DDISABLE, v.r, v.r);
  1916.            res := CatGlobal.FselGet (cfgPath, cfgName, '*.cfg', 'CFG-Datei ausw„hlen', TRUE);
  1917.            mtDials.DialForm (printConf, mtDials.DENABLE, v.r, v.r); 
  1918.            IF res & (cfgName[0] # '')
  1919.            THEN
  1920.              MagicStrings.Assign (cfgPath, cfgFile);
  1921.              MagicStrings.Append (cfgName, cfgFile);
  1922.              Printer.LoadCFGFile (cfgFile);
  1923.              IF Printer.Response = Printer.CFGnotFound
  1924.              THEN
  1925.                v.int := mtAlerts.Alert (1, cfgNotFound);
  1926.              ELSIF Printer.Response = Printer.wrongIdent
  1927.              THEN
  1928.                v.int := mtAlerts.Alert (1, noCfgFile);
  1929.              ELSIF Printer.Response = Printer.done
  1930.              THEN
  1931.                Printer.GetPrnName (name);
  1932.                mtUtils.SetObjcString (printConf, Fredrsc.Oselcfg, cfgName);
  1933.                mtUtils.SetObjcString (printConf, Fredrsc.Printname, name);
  1934.                mtUtils.CalcArea (printConf, Fredrsc.Printname, v.r);
  1935.                mtDials.DialDraw (printConf, 0, 8, v.r, TRUE);
  1936.              END;
  1937.            ELSIF res
  1938.            THEN
  1939.              Printer.FreeCFGFile();
  1940.              MagicStrings.Assign ('', cfgFile);
  1941.              Printer.GetPrnName (name);
  1942.              mtUtils.SetObjcString (printConf, Fredrsc.Printname, name);
  1943.              MagicStrings.Assign ('noname.cfg',cfgName);
  1944.              mtUtils.SetObjcString (printConf, Fredrsc.Oselcfg, cfgName);
  1945.              mtUtils.CalcArea (printConf, Fredrsc.Printname, v.r);
  1946.              mtDials.DialDraw (printConf, 0, 8, v.r, TRUE);
  1947.            END; 
  1948.            mtUtils.ExclState (printConf, but, MagicAES.SELECTED);
  1949.            mtDials.DialDraw (printConf, but, 0, v.r, FALSE); |  
  1950.     Fredrsc.Prok,
  1951.     Fredrsc.Prcancel: 
  1952.            EXIT; |
  1953.    ELSE
  1954.    END;
  1955.   END;
  1956.   IF but = Fredrsc.Prok
  1957.   THEN
  1958.     setGetOpts (FALSE);
  1959.     IF cfgFile[0] # '' THEN v.bool := ConfVars.SetConfigString (cPrtCfg, cfgFile); END;
  1960.   ELSE
  1961.     ConfVars.GetConfDefStr (cPrtCfg, cfgFile, '');
  1962.     IF cfgFile[0] # '' THEN Printer.LoadCFGFile (cfgFile); END;
  1963.   END;
  1964.   mtUtils.ExclState (printConf, but, MagicAES.SELECTED);
  1965.   mtDials.DialForm (printConf, mtDials.DFINISH, v.r, v.r);
  1966.   mtDials.DisposeDial (printConf);
  1967.   MagicAES.WindUpdate (MagicAES.ENDMCTRL);
  1968. END doPrinter;
  1969. *)
  1970.  
  1971. PROCEDURE makeTmpName (VAR path, name: ARRAY OF CHAR);
  1972.  TYPE lBITSET = SET OF [0..31];  
  1973.   VAR currentPath: CatTypes.String255;
  1974.       tname     : CatTypes.String127;
  1975.       mtime,
  1976.       sec       : LONGCARD;
  1977. BEGIN
  1978.   (* Aktuellen Pfad merken *)
  1979.   CatFiles.GetPath (currentPath);
  1980.   (* TmpDir holen *)
  1981.   IF ~mtCommand.EnvVar ('TMP', path)
  1982.   THEN
  1983.     (* tmpDir ist aktuelles Verzeichnis! *)
  1984.     MagicStrings.Assign (currentPath, path);
  1985.   END;
  1986.   (* Tmp-Pfad setzen *)
  1987.   v.bool := CatFiles.SetPath (path);
  1988.   (* Dateinamen basteln aus Inhalt des 200 Hz Timers *)
  1989.   REPEAT
  1990.     mtime := MagicXBIOS.Random();
  1991.     MagicStrings.Assign ('CT', tname);
  1992.     MagicStrings.Append (StrConv.LNumToStr (mtime, 36, 6, '0'), tname);
  1993.     (* Jetzt testen, ob Datei schon vorhanden *)
  1994.     MagicStrings.Assign (tname, name);
  1995.     sec := CatFiles.FileSize (name, v.bool);
  1996.   UNTIL ~v.bool;
  1997.   (* Aktuellen Pfad wiederherstellen *)
  1998.   v.bool := CatFiles.SetPath (currentPath);
  1999. END makeTmpName;
  2000.  
  2001. PROCEDURE buildCommand (REF com, path, in, out: ARRAY OF CHAR; VAR cmd : ARRAY OF CHAR);
  2002. (* In dieser Prozedur werden haupts„chlich Strings ersetzt 
  2003.  * Das eigentliche zusammenbauen der Kommandozeile wird von einer
  2004.  * Prozedur weiter oben in der Hierarchie erledigt 
  2005.  * Folgendes wird ersetzt: $B fr Eingabeblock durch ersten Namen (in),
  2006.  * $O fr Ausgabe des Kommandos durch zweiten Namen
  2007.  *)
  2008.  VAR tname  : CatTypes.String255;
  2009. BEGIN
  2010.   MagicStrings.Assign (path, tname);
  2011.   MagicStrings.Append (in, tname);
  2012.   MagicStrings.Assign (com, cmd);
  2013.   CatGlobal.ReplaceStr (cmd, '$B', tname);
  2014.   MagicStrings.Assign (path, tname);
  2015.   MagicStrings.Append (out, tname);
  2016.   CatGlobal.ReplaceStr (cmd, '$O', tname);
  2017. END buildCommand;
  2018.  
  2019. PROCEDURE PipeEditBlock (wdw: INTEGER; REF command: ARRAY OF CHAR);
  2020.   VAR path,
  2021.       tname,
  2022.       inName,
  2023.       outName : CatTypes.String255;
  2024.       len     : LONGCARD;
  2025.       cmdLine : CatTypes.String255;
  2026. BEGIN
  2027.   (* Vorgehensweise: 2*tmpFileName erstellen (in und out)
  2028.    * Kommando mit Redirection an shell absetzen 
  2029.    * kommando <in >out
  2030.    *)
  2031.   makeTmpName (path, inName);
  2032.   (* Block aus Editor schreiben *)
  2033.   CatEdit.EditSave (wdw, path, inName, FALSE);
  2034.   (* zweiten tmpnamen basteln *)
  2035.   makeTmpName (path, outName);
  2036.   (* Shellkommando basteln *)
  2037.   buildCommand (command, path, inName, outName, cmdLine);
  2038.   (* Shellkommando aufrufen *)
  2039.   ShellCall.CallShell (cmdLine, TRUE);
  2040.   (* Testen, ob Ausgabe existiert und l„nger als 0 Bytes ist *)
  2041.   MagicStrings.Assign (path, tname);
  2042.   MagicStrings.Append (outName, tname);
  2043.   len := CatFiles.FileSize (tname, v.bool);
  2044.   IF v.bool & (len > 0) 
  2045.   THEN
  2046.     (* Ausgabe in Editor einlesen *)
  2047.     CatEdit.EditPasteFile (wdw, TRUE, path, outName);
  2048.   END;
  2049.   (* tempor„re Files wieder l”schen *)
  2050.   v.bool := CatFiles.DeleteFile (path, inName);
  2051.   v.bool := CatFiles.DeleteFile (path, outName);
  2052. END PipeEditBlock;
  2053.  
  2054. PROCEDURE ProcessFilter (wdw: INTEGER; withDial: BOOLEAN);
  2055.   VAR cmd       : CatTypes.String255;
  2056. BEGIN
  2057.   IF (withDial & doFilter (filterNumber, cmd)) OR
  2058.      (~withDial & doPopupFilter (filterNumber, cmd))
  2059.   THEN
  2060.     IF filterNumber <= 6
  2061.     THEN
  2062.       CASE filterNumber OF
  2063.         0   : CatEdit.BlockRot  (wdw); |
  2064.         1   : CatEdit.BlockRot18 (wdw); |
  2065.         2   : CatEdit.BlockSwap (wdw); |
  2066.         3   : CatEdit.BlockUp   (wdw); |
  2067.         4   : CatEdit.BlockDown (wdw); |
  2068.         5   : CatEdit.BlockCapitals (wdw); |
  2069.         6   : CatEdit.BlockMirror (wdw); |
  2070.       ELSE
  2071.       END;
  2072.     ELSE
  2073.       IF LENGTH(cmd) > 0
  2074.       THEN
  2075.         PipeEditBlock (wdw, cmd);
  2076.       END;
  2077.     END;
  2078.   END;
  2079. END ProcessFilter;
  2080.  
  2081. PROCEDURE GetOrSetMark (getIt : BOOLEAN; wdw : INTEGER);
  2082. VAR exit   : INTEGER;
  2083.     str    : ARRAY[0..10] OF CHAR;
  2084.     nr: INTEGER;
  2085. BEGIN
  2086.   IF getIt 
  2087.   THEN
  2088.     mtUtils.SetObjcString (gotoBox, Fredrsc.Setmark, "Marke anspringen");
  2089.   ELSE
  2090.     mtUtils.SetObjcString (gotoBox, Fredrsc.Setmark, "Marke setzen");
  2091.   END;
  2092.   exit    := FormHandle (Fredrsc.Gotobox);
  2093.   IF exit # Fredrsc.Mbquit THEN
  2094.     IF getIt
  2095.     THEN
  2096.       CatEdit.ToMark (wdw, exit-Fredrsc.Mb1);
  2097.     ELSE
  2098.       CatEdit.SetMark (wdw, exit-Fredrsc.Mb1);
  2099.     END;
  2100.   END;
  2101. END GetOrSetMark;
  2102.  
  2103. PROCEDURE GetLine (wdw : INTEGER);
  2104. VAR exit   : INTEGER;
  2105.     str    : ARRAY[0..10] OF CHAR;
  2106.     nr: LONGINT;
  2107. BEGIN
  2108.   mtUtils.SetObjcString (lineBox, Fredrsc.Zeilennr, "");
  2109.   exit    := FormHandle (Fredrsc.Linebox);
  2110.   IF exit = Fredrsc.Zeileok THEN
  2111.     mtUtils.ObjcString (lineBox, Fredrsc.Zeilennr, str);
  2112.     v.card := 0;
  2113.     nr := StrConv.StrToLInt (str, v.card, v.bool);
  2114.     IF v.bool
  2115.     THEN
  2116.       CatEdit.ToLineNr (wdw, nr);
  2117.     END;
  2118.   END;
  2119. END GetLine;
  2120.  
  2121. PROCEDURE GetTabSize (wdw : INTEGER);
  2122. VAR exit   : INTEGER;
  2123.     str    : ARRAY[0..20] OF CHAR;
  2124.     nr: INTEGER;
  2125.     redraw: BOOLEAN;
  2126.     varname : CatTypes.String127;
  2127.     i       : INTEGER;
  2128.     isTop   : BOOLEAN;
  2129. BEGIN
  2130.   (* Box initialisieren *)
  2131.   isTop := CatEdit.IsEditTop (wdw);
  2132.  
  2133.   mtUtils.SetState (tabBox, Fredrsc.Taext0, MagicAES.DISABLED, ~isTop);
  2134.   mtUtils.SetState (tabBox, Fredrsc.Tatabw0, MagicAES.DISABLED, ~isTop);
  2135.   mtUtils.SetState (tabBox, Fredrsc.Taumbr0, MagicAES.DISABLED, ~isTop);
  2136.   mtUtils.SetState (tabBox, Fredrsc.Tartab0, MagicAES.DISABLED, ~isTop);
  2137.   mtUtils.SetState (tabBox, Fredrsc.Taback0, MagicAES.DISABLED, ~isTop);
  2138.   mtUtils.SetState (tabBox, Fredrsc.Talinel0, MagicAES.DISABLED, ~isTop);
  2139.   mtUtils.SetFlag (tabBox, Fredrsc.Talinel0, MagicAES.EDITABLE, isTop);
  2140.   mtUtils.SetFlag (tabBox, Fredrsc.Tatabw0, MagicAES.EDITABLE, isTop);
  2141.   IF isTop
  2142.   THEN
  2143.     (* Erstmal die Topwindow-Sachen *)
  2144.     CatEdit.GetTabsize (wdw, nr);
  2145.     mtUtils.SetObjcString (tabBox, Fredrsc.Tatabw0, StrConv.IntToStr (nr,0));
  2146.     SetItem (tabBox, Fredrsc.Taumbr0, CatEdit.GetMode (wdw, CatEdit.wrapMode));
  2147.     SetItem (tabBox, Fredrsc.Taback0, CatEdit.GetMode (wdw, CatEdit.autoBackup));
  2148.     SetItem (tabBox, Fredrsc.Tartab0, CatEdit.GetMode (wdw, CatEdit.tabMode));
  2149.     CatEdit.GetMargins (wdw, nr);
  2150.     mtUtils.SetObjcString (tabBox, Fredrsc.Talinel0, StrConv.IntToStr (nr,0));
  2151.   END;
  2152.   (* Und jetzt die ber die Configstrings *)
  2153.   FOR i := 1 TO 8 DO
  2154.     buildVarName (cExtension, i, varname);
  2155.     ConfVars.GetConfDefStr (varname, str, "");
  2156.     mtUtils.SetObjcString (tabBox, Fredrsc.Taext1+i-1, str);
  2157.     buildVarName (cExtTabsize, i, varname);
  2158.     ConfVars.GetConfDefInt (varname, nr, 4);
  2159.     mtUtils.SetObjcString (tabBox, Fredrsc.Tatabw1+i-1, StrConv.IntToStr (nr,0));
  2160.     buildVarName (cExtHardTabs, i, varname);
  2161.     ConfVars.GetConfDefBool (varname, v.bool, FALSE);
  2162.     SetItem (tabBox, Fredrsc.Tartab1+i-1, v.bool);
  2163.     buildVarName (cExtWordWrap, i, varname);
  2164.     ConfVars.GetConfDefBool (varname, v.bool, FALSE);
  2165.     SetItem (tabBox, Fredrsc.Taumbr1+i-1, v.bool);
  2166.     buildVarName (cExtRightMargin, i, varname);
  2167.     ConfVars.GetConfDefInt (varname, nr, 255);
  2168.     mtUtils.SetObjcString (tabBox, Fredrsc.Talinel1+i-1, StrConv.IntToStr (nr,0));
  2169.     buildVarName (cExtAutoBackup, i, varname);
  2170.     ConfVars.GetConfDefBool (varname, v.bool, FALSE);
  2171.     SetItem (tabBox, Fredrsc.Taback1+i-1, v.bool);
  2172.   END;
  2173.  
  2174.   exit    := FormHandle (Fredrsc.Tabbox);
  2175.   IF exit = Fredrsc.Tabok THEN
  2176.  
  2177.     redraw := FALSE;
  2178.     (* Erstmal die Topwindow-Sachen *)
  2179.     CatEdit.SetMode (wdw, CatEdit.wrapMode, GetItem (tabBox, Fredrsc.Taumbr0));
  2180.     CatEdit.SetMode (wdw, CatEdit.autoBackup, GetItem (tabBox, Fredrsc.Taback0));
  2181.     CatEdit.SetMode (wdw, CatEdit.tabMode, GetItem (tabBox, Fredrsc.Tartab0));
  2182.     mtUtils.ObjcString (tabBox, Fredrsc.Tatabw0, str);
  2183.     v.card := 0;
  2184.     nr := StrConv.StrToInt (str, v.card, v.bool);
  2185.     IF v.bool
  2186.     THEN
  2187.       CatEdit.SetTabsize (wdw, nr);
  2188.       IF CatEdit.GetMode (wdw, CatEdit.tabMode)
  2189.       THEN
  2190.         redraw := TRUE;
  2191.       END;
  2192.     END;
  2193.     mtUtils.ObjcString (tabBox, Fredrsc.Talinel0, str);
  2194.     v.card := 0;
  2195.     nr := StrConv.StrToInt (str, v.card, v.bool);
  2196.     IF v.bool
  2197.     THEN
  2198.       CatEdit.SetMargins (wdw, nr, GetItem (tabBox, Fredrsc.Taumbr0));
  2199.       redraw := TRUE;
  2200.     END;
  2201.     IF redraw
  2202.     THEN
  2203.       WdwManager.FullRedrawWdw (wdw);
  2204.     END;
  2205.  
  2206.     (* Und jetzt die ber die Configstrings *)
  2207.     FOR i := 1 TO 8 DO
  2208.       mtUtils.ObjcString (tabBox, Fredrsc.Taext1+i-1, str);
  2209.       IF str[0] # ''
  2210.       THEN
  2211.         buildVarName (cExtension, i, varname);
  2212.         v.bool := ConfVars.SetConfigString (varname, str);
  2213.         mtUtils.ObjcString (tabBox, Fredrsc.Tatabw1+i-1, str);
  2214.         v.card := 0;
  2215.         nr := StrConv.StrToInt (str, v.card, v.bool);
  2216.         IF v.bool
  2217.         THEN
  2218.           buildVarName (cExtTabsize, i, varname);
  2219.           v.bool := ConfVars.SetConfigInt (varname, nr);
  2220.         END;
  2221.         buildVarName (cExtHardTabs, i, varname);
  2222.         v.bool := ConfVars.SetConfigBool (varname, GetItem (tabBox, Fredrsc.Tartab1+i-1));
  2223.         buildVarName (cExtWordWrap, i, varname);
  2224.         v.bool := ConfVars.SetConfigBool (varname, GetItem (tabBox, Fredrsc.Taumbr1+i-1));
  2225.         mtUtils.ObjcString (tabBox, Fredrsc.Talinel1+i-1, str);
  2226.         v.card := 0;
  2227.         nr := StrConv.StrToInt (str, v.card, v.bool);
  2228.         IF v.bool
  2229.         THEN
  2230.           buildVarName (cExtRightMargin, i, varname);
  2231.           v.bool := ConfVars.SetConfigInt (varname, nr);
  2232.         END;
  2233.         buildVarName (cExtAutoBackup, i, varname);
  2234.         v.bool := ConfVars.SetConfigBool (varname, GetItem (tabBox, Fredrsc.Taback1+i-1));
  2235.       END;
  2236.     END;
  2237.   END;
  2238. END GetTabSize;
  2239.  
  2240. PROCEDURE GetRightMargin (wdw : INTEGER);
  2241. VAR exit   : INTEGER;
  2242.     str    : ARRAY[0..10] OF CHAR;
  2243.     nr     : INTEGER;
  2244.     umbr   : BOOLEAN;
  2245. BEGIN
  2246.   SetItem (umbruchBox, Fredrsc.Umbruchan, CatEdit.GetMode (wdw, CatEdit.wrapMode));
  2247.   CatEdit.GetMargins (wdw, nr);
  2248.   mtUtils.SetObjcString (umbruchBox, Fredrsc.Uspalte, StrConv.IntToStr (nr,0));
  2249.   exit    := FormHandle (Fredrsc.Umbruch);
  2250.   IF exit = Fredrsc.Umbrok THEN
  2251.     mtUtils.ObjcString (umbruchBox, Fredrsc.Uspalte, str);
  2252.     v.card := 0;
  2253.     nr := StrConv.StrToInt (str, v.card, v.bool);
  2254.     umbr := GetItem (umbruchBox, Fredrsc.Umbruchan);
  2255.     IF v.bool OR ~umbr
  2256.     THEN
  2257.       IF umbr
  2258.       THEN
  2259.         CatEdit.SetMargins (wdw, nr, umbr);
  2260.       ELSE
  2261.         CatEdit.SetMargins (wdw, maxLineLength, umbr);
  2262.       END;
  2263.       WdwManager.FullRedrawWdw (wdw);
  2264.     END;
  2265.   END;
  2266. END GetRightMargin;
  2267.  
  2268. PROCEDURE doShortBox ();
  2269.   VAR exit : INTEGER;
  2270.       path : MaxStr;
  2271.       name : ARRAY [0..40] OF CHAR;
  2272. BEGIN
  2273.   (* String setzen *)
  2274.   IF shortFileRead 
  2275.   THEN
  2276.     FileNames.SplitPath (lastShort, path, name);
  2277.   ELSE
  2278.     Strings.Assign ('', name, v.bool);
  2279.   END;
  2280.   mtUtils.SetObjcString (shortBox, Fredrsc.Sbinfo, name);
  2281.   exit    := FormHandle (Fredrsc.Shortbox);
  2282.   IF exit = Fredrsc.Sbkill
  2283.   THEN
  2284.     CatEdit.FreeShortkeyList();
  2285.     shortFileRead := FALSE;
  2286.     ConfVars.DeleteConfigVar (cShortFile);
  2287.   ELSIF exit = Fredrsc.Sbload
  2288.   THEN
  2289.     FileNames.SplitPath (lastShort, path, name);
  2290.     IF FselGet(path, name, '*.krz', 'Krzeldatei laden', FALSE)
  2291.     THEN
  2292.       Strings.Assign (path, lastShort, v.bool);
  2293.       Strings.Append (name, lastShort, v.bool);
  2294.       CatEdit.ReadShortkeyFile (lastShort);
  2295.       v.bool := ConfVars.SetConfigString (cShortFile, lastShort);
  2296.       shortFileRead := TRUE;
  2297.     END;
  2298.   END;
  2299. END doShortBox;
  2300.  
  2301. PROCEDURE doFileInfos (wdw : INTEGER);
  2302.   VAR lines, bytes, totalMem : LONGCARD;
  2303.       exit, edits : INTEGER;
  2304.       fname : ARRAY [0..20] OF CHAR;
  2305. BEGIN
  2306.   IF CatEdit.FileInfos (wdw, lines, bytes, edits, totalMem, fname)
  2307.   THEN
  2308.     (* Parameter setzen *)
  2309.     mtUtils.SetObjcString (infoBox, Fredrsc.Finame, fname);
  2310.     mtUtils.SetObjcString (infoBox, Fredrsc.Fisize, StrConv.CardToStr(bytes,0));
  2311.     mtUtils.SetObjcString (infoBox, Fredrsc.Fiusedm, StrConv.CardToStr(totalMem,0));
  2312.     mtUtils.SetObjcString (infoBox, Fredrsc.Filines, StrConv.CardToStr (lines,0));
  2313.     mtUtils.SetObjcString (infoBox, Fredrsc.Fifiles, StrConv.IntToStr (edits,0));
  2314.     mtUtils.SetObjcString (infoBox, Fredrsc.Fimem, StrConv.CardToStr (MemAvail(),0));
  2315.     (* Box aufrufen *)
  2316.     exit := FormHandle (Fredrsc.Fileinfo);
  2317.   END;
  2318. END doFileInfos;
  2319.  
  2320.  
  2321. TYPE floskelArray =  ARRAY [1..20] OF ARRAY[0..511] OF CHAR;
  2322.  
  2323.      floskelInfo = RECORD
  2324.                      txtArray : POINTER TO floskelArray;
  2325.                      oldEntry : INTEGER;
  2326.                      oldShift : BOOLEAN;
  2327.                      theWdw   : INTEGER;
  2328.                    END;
  2329.     floskelPtr = POINTER TO floskelInfo;
  2330.     
  2331.   PROCEDURE SetStrings (tree: ADDRESS; from, to : INTEGER; REF string : ARRAY OF CHAR);
  2332.     VAR i         : INTEGER;
  2333.         entryLen  : INTEGER;
  2334.         obIdx     : INTEGER;
  2335.         str       : ARRAY [0..79] OF CHAR;
  2336.   BEGIN
  2337.     (* Alle Textfelder l”schen *)
  2338.     FOR i := from TO to DO
  2339.       mtUtils.SetObjcString (tree, i, '');
  2340.     END;
  2341.     i := 0;
  2342.     obIdx := from;
  2343.     WHILE (i < INTEGER(LENGTH (string))) & (obIdx <= to) DO
  2344.       mtUtils.ObjcStrLen (tree, obIdx, entryLen, v.int);
  2345.       DEC (entryLen, 4);
  2346.       MagicStrings.Copy (string, i, entryLen-1, str);
  2347.       mtUtils.SetObjcString (tree, obIdx, str);
  2348.       INC (obIdx);
  2349.       INC (i, entryLen-1);
  2350.     END;
  2351.   END SetStrings;
  2352.  
  2353.   PROCEDURE SetEntry (tree: ADDRESS; floskel : floskelPtr;
  2354.                       idx : INTEGER; isShift : BOOLEAN);
  2355.     VAR i       : INTEGER;
  2356.         str     : ARRAY  [0..1023] OF CHAR;
  2357.         strIdx    : INTEGER;
  2358.   BEGIN
  2359.     strIdx := idx - Fredrsc.Fl_f1 + 1;
  2360.     IF isShift THEN INC (strIdx, 10) END;
  2361.     (* Suchen nach einzelnen LFs und ersetzen davon *)
  2362.     Strings.Assign (floskel^.txtArray^[strIdx], str, v.bool);
  2363.     i := 0;
  2364.     WHILE i >= 0 DO
  2365.       i := Strings.Pos (LF, str, i);
  2366.       IF i >= 0
  2367.       THEN
  2368.         Strings.Delete (str, i, 1, v.bool);
  2369.       END;
  2370.     END;
  2371.     CatGlobal.SetStrings (tree, Fredrsc.Flline1, Fredrsc.Flline6, str);
  2372.   END SetEntry;
  2373.   
  2374.   PROCEDURE GetEntry (tree: ADDRESS; floskel : floskelPtr;
  2375.                       idx : INTEGER; isShift : BOOLEAN);
  2376.     VAR i       : INTEGER;
  2377.         str     : ARRAY  [0..1023] OF CHAR;
  2378.         strIdx  : INTEGER;
  2379.   BEGIN 
  2380.     strIdx := idx - Fredrsc.Fl_f1 + 1;
  2381.     IF isShift THEN INC (strIdx, 10) END;
  2382.     CatGlobal.GetStrings (tree, Fredrsc.Flline1, Fredrsc.Flline6, floskel^.txtArray^[strIdx]);
  2383.     i := 0; 
  2384.     (* Suchen nach einzelnen CRs und diese ersetzen durch Cr/LF *)
  2385.     Strings.Assign (floskel^.txtArray^[strIdx], str, v.bool);
  2386.     WHILE i >= 0 DO
  2387.       i := Strings.Pos (CR, str, i);
  2388.       IF i >= 0
  2389.       THEN
  2390.         IF str[i+1] # LF
  2391.         THEN
  2392.           Strings.Insert (LF, i+1, str, v.bool);
  2393.         END;
  2394.         INC (i);
  2395.       END;
  2396.     END;
  2397.     (* Suchen nach einzelnen LFs und ersetzen davon *)
  2398.     i := 0;
  2399.     WHILE i >= 0 DO
  2400.       i := Strings.Pos (LF, str, i);
  2401.       IF i >= 0
  2402.       THEN
  2403.         IF (i=0) OR ((i > 0) & (str[i-1] # CR))
  2404.         THEN
  2405.           Strings.Insert (CR, i, str, v.bool);
  2406.         END;
  2407.         INC (i);
  2408.       END;
  2409.     END;
  2410.     (* Jetzt nur noch in Textarray sichern *)
  2411.     Strings.Assign (str, floskel^.txtArray^[strIdx], v.bool);
  2412.   END GetEntry;
  2413.  
  2414. PROCEDURE floskelButton (tree: ADDRESS; private: ADDRESS; button: INTEGER;
  2415.                          mx, my : INTEGER; kstate: BITSET; clicks: INTEGER): BOOLEAN;
  2416.   VAR   floskel : floskelPtr;
  2417.         but     : INTEGER;
  2418.         isShift: BOOLEAN;
  2419.         strPtr  : CatTypes.Str1023Ptr;
  2420.         strLen  : LONGCARD;
  2421. BEGIN
  2422.   floskel := private;
  2423.   but := INTEGER(BITSET(button) - {15});
  2424.   CASE but OF
  2425.     Fredrsc.Fl_f1..Fredrsc.Fl_f10 :
  2426.       GetEntry (tree, floskel, floskel^.oldEntry, floskel^.oldShift);
  2427.       isShift := mtUtils.InState (tree, Fredrsc.Fl_shift, MagicAES.SELECTED);
  2428.       SetEntry (tree, floskel, but, isShift);
  2429.       floskel^.oldShift := isShift;
  2430.       floskel^.oldEntry   := but; 
  2431.       WinDials.WinDialDraw (tree, Fredrsc.Flbox, 2, v.r, FALSE);
  2432.       |
  2433.     Fredrsc.Fl_shift: 
  2434.       GetEntry (tree, floskel, floskel^.oldEntry, floskel^.oldShift);
  2435.       isShift := mtUtils.InState (tree, Fredrsc.Fl_shift, MagicAES.SELECTED);
  2436.       SetEntry (tree, floskel, floskel^.oldEntry, isShift);
  2437.       floskel^.oldShift := isShift;
  2438.       WinDials.WinDialDraw (tree , Fredrsc.Flbox, 2, v.r, FALSE);
  2439.       |
  2440.     Fredrsc.Flblock:
  2441.       IF CatEdit.GetBlock (floskel^.theWdw, FALSE, TRUE, strPtr, strLen)
  2442.       THEN
  2443.         IF strLen > 512 THEN strPtr^[511] := 0C END;
  2444.         CatGlobal.SetStrings (tree, Fredrsc.Flline1, Fredrsc.Flline6, strPtr^);
  2445.         GetEntry (tree, floskel, floskel^.oldEntry, floskel^.oldShift);
  2446.         SetEntry (tree, floskel, floskel^.oldEntry, floskel^.oldShift);
  2447.         WinDials.WinDialDraw (tree , Fredrsc.Flbox, 2, v.r, FALSE);
  2448.         DEALLOCATE (strPtr, 0);
  2449.         mtUtils.ExclState (tree, but, MagicAES.SELECTED);
  2450.         WinDials.WinDialDraw (tree, but, 0, v.r, FALSE);
  2451.       END;
  2452.       |
  2453.     Fredrsc.Flok,
  2454.     Fredrsc.Flcancel:
  2455.       mtUtils.ExclState (tree, but, MagicAES.SELECTED);
  2456.       GetEntry (tree, floskel, floskel^.oldEntry, floskel^.oldShift);
  2457.       RETURN TRUE; |
  2458.   ELSE
  2459.   END;
  2460.   RETURN FALSE;
  2461. END floskelButton;
  2462.  
  2463. PROCEDURE floskelGetSetValues (tree: ADDRESS; private: ADDRESS; 
  2464.                                set: BOOLEAN; exit: INTEGER);
  2465.   VAR   floskel : floskelPtr;
  2466.         i       : INTEGER;
  2467.         found   : BOOLEAN;
  2468.         isShift: BOOLEAN;
  2469.         str     : ARRAY [0..511] OF CHAR;
  2470.         varName : CatTypes.String127;
  2471.         but     : INTEGER;
  2472. BEGIN
  2473.   floskel := private;
  2474.   but := INTEGER(BITSET(exit) - {15});
  2475.   IF set
  2476.   THEN
  2477.     FOR i := 1 TO 10 DO 
  2478.       buildVarName (cNormalFkey, i, varName);
  2479.       ConfVars.GetConfDefStr (varName, floskel^.txtArray^[i], '');
  2480.     END;
  2481.     mtUtils.SetState (tree, Fredrsc.Flblock, MagicAES.DISABLED, 
  2482.                       ~(CatEdit.IsEditTop (floskel^.theWdw) & 
  2483.                         CatEdit.BlockIsMarked (floskel^.theWdw)));
  2484.     FOR i := 1 TO 10 DO 
  2485.       buildVarName (cShiftFkey, i, varName);
  2486.       ConfVars.GetConfDefStr (varName, floskel^.txtArray^[10+i], '');
  2487.     END;
  2488.     (* Selektierten Eintrag feststellen *)
  2489.     i := Fredrsc.Fl_f1;
  2490.     found := FALSE;
  2491.     WHILE ~found & (i <= Fredrsc.Fl_f10) DO
  2492.       found := mtUtils.InState (tree, i, MagicAES.SELECTED);
  2493.       IF ~found THEN INC (i); END;
  2494.     END;
  2495.     isShift := mtUtils.InState (tree, Fredrsc.Fl_shift, MagicAES.SELECTED);
  2496.     SetEntry (tree, floskel, i, isShift);
  2497.     floskel^.oldEntry := i; 
  2498.     floskel^.oldShift := isShift;
  2499.   ELSE
  2500.     IF but = Fredrsc.Flok
  2501.     THEN
  2502.       (* Strings abspeichern *)
  2503.       FOR i := 1 TO 10 DO 
  2504.         buildVarName (cNormalFkey, i, varName);
  2505.         IF ConfVars.GetConfigString (varName, str) OR (LENGTH (floskel^.txtArray^[i]) > 0) THEN
  2506.           v.bool := ConfVars.SetConfigString (varName, floskel^.txtArray^[i]);
  2507.         END;
  2508.       END;
  2509.       FOR i := 1 TO 10 DO 
  2510.         buildVarName (cShiftFkey, i, varName);
  2511.         IF ConfVars.GetConfigString (varName, str) OR (LENGTH (floskel^.txtArray^[10+i]) > 0) THEN
  2512.           v.bool := ConfVars.SetConfigString (varName, floskel^.txtArray^[10+i]);
  2513.         END;
  2514.       END;
  2515.     END;
  2516.     DEALLOCATE (floskel^.txtArray, 0);
  2517.     DISPOSE (floskel);
  2518.   END;
  2519. END floskelGetSetValues;
  2520.  
  2521. PROCEDURE doFloskel();
  2522.   VAR floskelBox: mtUtils.tObjcTree;
  2523.       floskel   : floskelPtr;
  2524. BEGIN
  2525.   (* vorbereiten *)
  2526.   floskelBox := MagicAES.RsrcGaddr(MagicAES.RTREE, Fredrsc.Floskeln);
  2527.   NEW (floskel);
  2528.   IF floskel = NIL
  2529.   THEN
  2530.     RETURN
  2531.   END;
  2532.   ALLOCATE (floskel^.txtArray, TSIZE (floskelArray));
  2533.   IF floskel^.txtArray = NIL
  2534.   THEN
  2535.     DISPOSE (floskel);
  2536.     RETURN
  2537.   END; 
  2538.   floskel^.theWdw := WdwManager.theTopWindow;
  2539.   IF ~WinDials.OpenWinDial (floskelBox, FALSE, 
  2540.                             floskelGetSetValues,
  2541.                             floskelGetSetValues,
  2542.                             floskelButton,
  2543.                             WinDials.defDraw,
  2544.                             "",
  2545.                             floskel)
  2546.   THEN
  2547.     noWinDialAlert();
  2548.     DEALLOCATE (floskel^.txtArray, 0);
  2549.     DISPOSE (floskel);
  2550.   END;
  2551. END doFloskel;
  2552.  
  2553. (*
  2554. PROCEDURE doFloskelDialogue();
  2555.   TYPE floskelArray =  ARRAY [1..20] OF ARRAY[0..511] OF CHAR;
  2556.   VAR txtArray  : POINTER TO floskelArray;
  2557.       str       : ARRAY [0..511] OF CHAR;
  2558.   
  2559.   PROCEDURE SetStrings (REF string : ARRAY OF CHAR);
  2560.      VAR i       : INTEGER;
  2561.         entryLen  : INTEGER;
  2562.         obIdx   : INTEGER;
  2563.   BEGIN
  2564.     (* Alle Textfelder l”schen *)
  2565.     FOR i := Fredrsc.Flline1 TO Fredrsc.Flline6 DO
  2566.       mtUtils.SetObjcString (floskelBox, i, '');
  2567.     END;
  2568.     i := 0;
  2569.     obIdx := Fredrsc.Flline1;
  2570.     WHILE (i < INTEGER(LENGTH (string))) & (obIdx <= Fredrsc.Flline6) DO
  2571.       mtUtils.ObjcStrLen (floskelBox, obIdx, entryLen, v.int);
  2572.       Strings.Copy (string, i, entryLen-1, str, v.bool);
  2573.       mtUtils.SetObjcString (floskelBox, obIdx, str);
  2574.       INC (obIdx);
  2575.       INC (i, entryLen-1);
  2576.     END;
  2577.   END SetStrings;
  2578.     
  2579.   PROCEDURE SetEntry (idx : INTEGER; isShift : BOOLEAN);
  2580.     VAR strIdx    : INTEGER;
  2581.   BEGIN
  2582.     strIdx := idx - Fredrsc.Fl_f1 + 1;
  2583.     IF isShift THEN INC (strIdx, 10) END;
  2584.     SetStrings (txtArray^[strIdx]);
  2585.   END SetEntry;
  2586.   
  2587.   PROCEDURE GetEntry (idx : INTEGER; isShift : BOOLEAN);
  2588.     VAR i       : INTEGER;
  2589.         str     : ARRAY  [0..511] OF CHAR;
  2590.         strIdx  : INTEGER;
  2591.   BEGIN 
  2592.     strIdx := idx - Fredrsc.Fl_f1 + 1;
  2593.     IF isShift THEN INC (strIdx, 10) END;
  2594.     txtArray^[strIdx] := '';
  2595.     FOR i := Fredrsc.Flline1 TO Fredrsc.Flline6 DO
  2596.       mtUtils.ObjcString (floskelBox, i, str);
  2597.       Strings.Append (str, txtArray^[strIdx], v.bool);
  2598.     END;
  2599.   END GetEntry;
  2600.  
  2601. VAR
  2602.       i         : INTEGER;
  2603.       found, 
  2604.       isShift   : BOOLEAN;
  2605.       varName   : ARRAY [0..39] OF CHAR;
  2606.       but       : INTEGER;
  2607.       oldShift  : BOOLEAN;
  2608.       oldEntry  : INTEGER;
  2609.       strLen    : LONGCARD;
  2610.       strPtr    : POINTER TO ARRAY [0..1023] OF CHAR;
  2611. BEGIN
  2612.   (* vorbereiten *)
  2613.   IF ~InitDial (Fredrsc.Floskeln, floskelBox)
  2614.   THEN
  2615.     RETURN 
  2616.   END;
  2617.   ALLOCATE (txtArray, TSIZE (floskelArray));
  2618.   IF txtArray = NIL
  2619.   THEN
  2620.     EditFuncs.OutOfMem();
  2621.   END; 
  2622.   FOR i := 1 TO 10 DO 
  2623.     Strings.Assign (cNormalFkey, varName, v.bool);
  2624.     Strings.Append (StrConv.IntToStr (i,0), varName, v.bool);
  2625.     ConfVars.GetConfDefStr (varName, txtArray^[i], '');
  2626.   END;
  2627.   mtUtils.SetState (floskelBox, Fredrsc.Flblock, MagicAES.DISABLED, 
  2628.                     ~(CatEdit.IsEditTop (WdwManager.theTopWindow) & 
  2629.                       CatEdit.BlockIsMarked (WdwManager.theTopWindow)));
  2630.   FOR i := 1 TO 10 DO 
  2631.     Strings.Assign (cShiftFkey, varName, v.bool);
  2632.     Strings.Append (StrConv.IntToStr (i,0), varName, v.bool);
  2633.     ConfVars.GetConfDefStr (varName, txtArray^[10+i], '');
  2634.   END;
  2635.   (* Selektierten Eintrag feststellen *)
  2636.   i := Fredrsc.Fl_f1;
  2637.   found := FALSE;
  2638.   WHILE ~found & (i <= Fredrsc.Fl_f10) DO
  2639.     found := mtUtils.InState (floskelBox, i, MagicAES.SELECTED);
  2640.     IF ~found THEN INC (i); END;
  2641.   END;
  2642.   isShift := mtUtils.InState (floskelBox, Fredrsc.Fl_shift, MagicAES.SELECTED);
  2643.   SetEntry (i, isShift);
  2644.   oldEntry := i; 
  2645.   oldShift := isShift;
  2646.   mtDials.DialForm (floskelBox, mtDials.DSTART, v.r, v.r);
  2647.   mtDials.DialDraw (floskelBox, 0, 99, v.r, FALSE);
  2648.   LOOP
  2649.     but := mtDials.DialDo (floskelBox, 0);
  2650.     but := INTEGER(BITSET(but) - {15});
  2651.     CASE but OF
  2652.       Fredrsc.Fl_f1..Fredrsc.Fl_f10:
  2653.         GetEntry (oldEntry, oldShift);
  2654.         isShift := mtUtils.InState (floskelBox, Fredrsc.Fl_shift, MagicAES.SELECTED);
  2655.         SetEntry (but, isShift);
  2656.         oldShift := isShift;
  2657.         oldEntry   := but; 
  2658.         mtDials.DialDraw (floskelBox, Fredrsc.Flbox, 2, v.r, FALSE);
  2659.         |
  2660.       Fredrsc.Fl_shift:
  2661.         GetEntry (oldEntry, oldShift);
  2662.         isShift := mtUtils.InState (floskelBox, Fredrsc.Fl_shift, MagicAES.SELECTED);
  2663.         oldShift := isShift;
  2664.         SetEntry (oldEntry, isShift);
  2665.         mtDials.DialDraw (floskelBox , Fredrsc.Flbox, 2, v.r, FALSE);
  2666.         |
  2667.       Fredrsc.Flblock:
  2668.         v.bool := CatEdit.GetBlock (WdwManager.theTopWindow, TRUE, strPtr, strLen);
  2669.         IF strLen > 512 THEN strPtr^[511] := 0C END;
  2670.         SetStrings (strPtr^);
  2671.         GetEntry (oldEntry, oldShift);
  2672.         SetEntry (oldEntry, oldShift);
  2673.         mtDials.DialDraw (floskelBox , Fredrsc.Flbox, 2, v.r, FALSE);
  2674.         DEALLOCATE (strPtr, 0);
  2675.         mtUtils.ExclState (floskelBox, but, MagicAES.SELECTED);
  2676.         mtDials.DialDraw (floskelBox, but, 0, v.r, FALSE);
  2677.         |
  2678.       Fredrsc.Flok,
  2679.       Fredrsc.Flcancel:
  2680.         GetEntry (oldEntry, oldShift);
  2681.         EXIT |
  2682.     ELSE
  2683.     END;
  2684.   END;
  2685.   IF but = Fredrsc.Flok
  2686.   THEN
  2687.     (* Strings abspeichern *)
  2688.     FOR i := 1 TO 10 DO 
  2689.       Strings.Assign (cNormalFkey, varName, v.bool);
  2690.       Strings.Append (StrConv.IntToStr (i,0), varName, v.bool);
  2691.       IF ConfVars.GetConfigString (varName, str) OR (LENGTH (txtArray^[i]) > 0) THEN
  2692.         v.bool := ConfVars.SetConfigString (varName, txtArray^[i]);
  2693.       END;
  2694.     END;
  2695.     FOR i := 1 TO 10 DO 
  2696.       Strings.Assign (cShiftFkey, varName, v.bool);
  2697.       Strings.Append (StrConv.IntToStr (i,0), varName, v.bool);
  2698.       IF ConfVars.GetConfigString (varName, str) OR (LENGTH (txtArray^[10+i]) > 0) THEN
  2699.         v.bool := ConfVars.SetConfigString (varName, txtArray^[10+i]);
  2700.       END;
  2701.     END;
  2702.   END;
  2703.   mtUtils.ExclState (floskelBox, but, MagicAES.SELECTED);
  2704.   mtDials.DialForm (floskelBox, mtDials.DFINISH, v.r, v.r);
  2705.   DEALLOCATE (txtArray, 0);
  2706.   mtDials.DisposeDial (floskelBox);
  2707. END doFloskelDialogue;
  2708. *)
  2709.  
  2710. PROCEDURE DoAbout;
  2711. BEGIN
  2712.   v.int := FormHandle(Fredrsc.Aboutbox);
  2713. (*   IF v.int = Fredrsc.ainfo THEN v.int := FormHandle(info) END; *)
  2714. END DoAbout;
  2715.  
  2716. PROCEDURE doErrorBox;
  2717.   VAR errName : CatTypes.String255;
  2718. BEGIN
  2719.   ConfVars.GetConfDefStr (cErrExtension, errName, '');
  2720.   ConfVars.GetConfDefStr (cErrMask, errMask, '');
  2721.   mtUtils.SetObjcString (errorBox, Fredrsc.Efname, errName);
  2722.   mtUtils.SetObjcString (errorBox, Fredrsc.Emask, errMask);
  2723.   IF FormHandle(Fredrsc.Errbox) = Fredrsc.Eok
  2724.   THEN
  2725.     mtUtils.ObjcString (errorBox, Fredrsc.Efname, errName);
  2726.     mtUtils.ObjcString (errorBox, Fredrsc.Emask, errMask);
  2727.     v.bool := ConfVars.SetConfigString (cErrExtension, errName);
  2728.     v.bool := ConfVars.SetConfigString (cErrMask, errMask);
  2729.   END;
  2730. END doErrorBox;
  2731.  
  2732. PROCEDURE ClearScreen();
  2733. BEGIN
  2734.   MagicDOS.Cconout(33C); MagicDOS.Cconout('E');
  2735. END ClearScreen;
  2736.  
  2737. PROCEDURE ClearBuffer(e : BITSET; force : BOOLEAN; ks: BITSET; sc: INTEGER; char: CHAR);
  2738.   VAR kstate : BITSET;
  2739.       scan   : INTEGER;
  2740.       ch     : CHAR;
  2741. BEGIN
  2742.   IF MagicAES.MUKEYBD IN e THEN
  2743.     REPEAT
  2744.       e := MagicAES.EvntMulti(
  2745.                {MagicAES.MUKEYBD, MagicAES.MUTIMER},
  2746.                 0,{},{}, 0,dr, 0,dr, mScrap, 0,0,
  2747.                 v.int, v.int, v.bset, v.int, kstate, scan, ch, v.int);
  2748.     UNTIL ~(MagicAES.MUKEYBD IN e) OR (CAP(char) IN CatTypes.charSet{'A'..'Z','0'..'9'}) 
  2749.         OR (~force & ((ks#kstate) OR (scan # sc)));
  2750.     IF MagicAES.MUKEYBD IN e
  2751.     THEN
  2752.       PushKey (kstate, CHR(scan), ch);
  2753.     END;
  2754.   END;
  2755. END ClearBuffer;
  2756.  
  2757.  
  2758. VAR shellCommand : ARRAY[0..65] OF CHAR;
  2759.  
  2760. PROCEDURE DoShell();
  2761.   VAR j : INTEGER;
  2762. BEGIN
  2763.   mtUtils.SetObjcString(systemBox, Fredrsc.Sysstr, shellCommand);
  2764.   IF FormHandle(Fredrsc.Systembx) # Fredrsc.Sysabruc THEN
  2765.     mtUtils.ObjcString(systemBox, Fredrsc.Sysstr, shellCommand);
  2766.     IF shell = ShellCall.shellP
  2767.     THEN
  2768.       mtAppl.MouseOff;
  2769.       ClearScreen();
  2770.       MagicAES.WindUpdate(MagicAES.ENDUPDATE);
  2771.     END;
  2772.     ShellCall.CallShell(shellCommand, FALSE);
  2773.     IF shell = ShellCall.shellP
  2774.     THEN
  2775.       MagicAES.WindUpdate(MagicAES.BEGUPDATE);
  2776.       MagicDOS.Cconout(CR); MagicDOS.Cconout(LF);
  2777.       MagicDOS.Cconws('- Taste drcken -');
  2778.       ClearBuffer({MagicAES.MUKEYBD}, TRUE, {}, 0, 0C);
  2779.       MagicAES.EvntKeybd(v.int, v.int, v.char);
  2780.       MagicDOS.Cconws(33C+'f'+0C);        (* Cursor ausschalten *)
  2781.       mtAppl.MouseArrow;
  2782.  
  2783.       MagicAES.FormDial(MagicAES.FMDFINISH, null, EditTypes.deskSize);
  2784.       v.int := MagicAES.MenuBar(menu, MagicAES.Set);
  2785.     END;
  2786.  
  2787.   ELSE
  2788.     mtUtils.SetObjcString(systemBox, Fredrsc.Sysstr, shellCommand);
  2789.   END;
  2790. END DoShell;
  2791.  
  2792. PROCEDURE DoSelectFont (wdw : INTEGER);
  2793.  VAR hdl : INTEGER;
  2794.      font, size : INTEGER;
  2795.      fInfo      : FontSelect.tFontinfo;
  2796.      name       : ARRAY [0..45] OF CHAR;
  2797. BEGIN
  2798.   IF CatEdit.IsEditTop (wdw)
  2799.   THEN
  2800.     CatEdit.GetEditVDIHandle (wdw, hdl);
  2801.     font := FontSelect.FontActive (hdl);
  2802.     FontSelect.FontInfo (hdl, font, fInfo);
  2803.     size := fInfo.point;
  2804.     IF FontSelect.DoSelectFont (hdl, FALSE, font, size)
  2805.     THEN
  2806.       CatEdit.SelectEditFont (wdw, font, size);
  2807.     END;
  2808.   END;
  2809. END DoSelectFont;
  2810.  
  2811. PROCEDURE hdlComp (item, wdw : INTEGER);
  2812.   VAR isSaved : BOOLEAN;
  2813.       val     : ARRAY [0..511] OF CHAR;
  2814. BEGIN
  2815.   IF item = Fredrsc.Pcompile
  2816.   THEN 
  2817.     IF mm2shell
  2818.     THEN
  2819.       CatEdit.CompileText (wdw);
  2820.     ELSE
  2821.       (* Filenamen von TopWindow erfragen *)
  2822.       IF CatEdit.GetCompInfo (wdw, val, isSaved)
  2823.       THEN
  2824.         IF ~isSaved THEN 
  2825.           CatEdit.AskForSave (wdw);
  2826.         END;
  2827.         SendEsMessage (SEProto.ES_COMPILE, ADR(val));
  2828.       END;
  2829.     END;
  2830.   ELSE
  2831.     CatEdit.EditSave (wdw,'','', FALSE);
  2832.     quitProg := CatEdit.CloseAllEditors(FALSE);
  2833.     CASE item OF
  2834.       Fredrsc.Pcompend : termCode := 1 |
  2835.       Fredrsc.Pcomprun : termCode := 2 |
  2836.       Fredrsc.Pmake    : termCode := 3 |
  2837.       Fredrsc.Pmakerun : termCode := 4 |
  2838.     ELSE
  2839.     END;
  2840.   END;
  2841. END hdlComp;
  2842.  
  2843. PROCEDURE OpenEditor (REF path, name: ARRAY OF CHAR; VAR wdw: INTEGER; isErrFile: BOOLEAN): BOOLEAN; FORWARD;
  2844.  
  2845. PROCEDURE ParseErrLine (REF error, mask: ARRAY OF CHAR;
  2846.                         VAR errFile, errMess: ARRAY OF CHAR;
  2847.                         VAR errLine: LONGINT; VAR errRow : INTEGER): BOOLEAN;
  2848. VAR pIdx, 
  2849.     erIdx, elIdx,
  2850.     efIdx, emIdx : INTEGER;
  2851.     i, j, l      : INTEGER;
  2852.     searchPat    : Find2.tpPattern;
  2853.     ptrPatt      : Find2.tpPat;
  2854.     eIdx,
  2855.     sIdx         : INTEGER;
  2856.     pattern,
  2857.     eLine        : CatTypes.String255;
  2858.     numStr       : CatTypes.String127;
  2859.     found        : BOOLEAN;
  2860.  
  2861. BEGIN
  2862.   (* Zuerst bauen wir aus der Maske einen Suchstring auf, indem die 
  2863.    * einzelnen Felder durch Wildcards ersetzt werden
  2864.    * Damit das auch am Anfang und Ende des Strings funktioniert, wird dann
  2865.    * in den bergebenen String am Anfang ein Control-Zeichen eingefgt und
  2866.    * am Ende auch eines.
  2867.    *)
  2868.   (* Initialisierung *)
  2869.   MagicStrings.Assign ("", errFile);
  2870.   MagicStrings.Assign ("", errMess);
  2871.   errLine := -1;
  2872.   errRow := 0;
  2873.   (* Suchmuster aufbauen *)
  2874.   i := 0; j := 0;
  2875.   l := LENGTH (mask);
  2876.   pIdx := 0;
  2877.   efIdx := -1; elIdx := -1;
  2878.   emIdx := -1; erIdx := -1;
  2879.   WHILE i < l DO
  2880.     IF (mask[i] = '$') & (mask[i+1] IN  CatTypes.charSet {'F','L','M','R'})
  2881.     THEN
  2882.       CASE mask[i+1] OF
  2883.         'F' : efIdx := pIdx; |
  2884.         'L' : elIdx := pIdx; |
  2885.         'M' : emIdx := pIdx; |
  2886.         'R' : erIdx := pIdx; 
  2887.       ELSE
  2888.       END;
  2889.       INC (pIdx);
  2890.       pattern[j] := '*';
  2891.       INC (i); (* da i+1 schon ausgewertet wurde *)
  2892.     ELSE
  2893.       IF mask[i] = '*' THEN INC (pIdx); END;
  2894.       pattern[j] := mask[i];
  2895.     END;
  2896.     INC (j);
  2897.     INC (i);
  2898.   END;
  2899.   pattern[j] := 0C;
  2900.   (* Jetzt die bergebene Zeile kopieren und dann suchen *)
  2901.   MagicStrings.Assign (error, eLine);
  2902.   (* Steuerzeichen am Ende von error l”schen *)
  2903.   l := LENGTH (eLine) - 1;
  2904.   WHILE (l >= 0) & ((eLine[l] = 12C) OR (eLine[l] = 15C)) DO
  2905.     DEC (l);
  2906.   END;
  2907.   eLine[l+1] := 0C;
  2908.   (* Jetzt eigene Steuerzeichen einfgen *)
  2909.   MagicStrings.Insert (34C, pattern, 0);
  2910.   MagicStrings.Append (35C, pattern);
  2911.   MagicStrings.Insert (34C, eLine, 0);
  2912.   MagicStrings.Append (35C, eLine);
  2913.   (* Jetzt das Suchmuster compilieren *)
  2914.   
  2915.   searchPat := Find2.Compile (pattern, '?', 1C, '*', 35C, TRUE, FALSE);
  2916.   (* Jetzt suchen *)
  2917.   found := Find2.Find (ADR (eLine), LENGTH (eLine), searchPat, 0);
  2918.   IF found
  2919.   THEN
  2920.     (* Gefunden, jetzt auswerten *)
  2921.     eIdx := -1;
  2922.     sIdx := -1;
  2923.     pIdx := 0;
  2924.     ptrPatt := searchPat^.pFirst;
  2925.     WHILE ptrPatt # NIL DO
  2926.       IF sIdx >= 0
  2927.       THEN
  2928.         eIdx := SHORT(LONGINT(ADDRESS(ptrPatt^.pMatch)-ADR(eLine)));
  2929.         IF pIdx = efIdx
  2930.         THEN
  2931.           (* Filename *)
  2932.           Strings.Copy (eLine, sIdx, eIdx - sIdx, errFile, v.bool);
  2933.         ELSIF pIdx = elIdx
  2934.         THEN
  2935.           Strings.Copy (eLine, sIdx, eIdx - sIdx, numStr, v.bool);
  2936.           v.card := 0;
  2937.           errLine := StrConv.StrToLInt (numStr, v.card, v.bool);
  2938.         ELSIF pIdx = emIdx
  2939.         THEN
  2940.           Strings.Copy (eLine, sIdx, eIdx - sIdx, errMess, v.bool);
  2941.         ELSIF pIdx = erIdx
  2942.         THEN
  2943.           Strings.Copy (eLine, sIdx, eIdx - sIdx, numStr, v.bool);
  2944.           v.card := 0;
  2945.           errRow := StrConv.StrToInt (numStr, v.card, v.bool);
  2946.         END;
  2947.         INC (pIdx);
  2948.       END;
  2949.       sIdx := SHORT(LONGINT(ADDRESS(ptrPatt^.pMatch)-ADR(eLine))) + ptrPatt^.len;
  2950.       ptrPatt :=ptrPatt^.pNext;
  2951.     END;
  2952.   END;
  2953.   Find2.Dispose (searchPat);
  2954.   RETURN found;
  2955. END ParseErrLine;
  2956.  
  2957. PROCEDURE handleErrorLine (wdw: INTEGER; REF error: ARRAY OF CHAR);
  2958.   VAR errF : CatTypes.String255;
  2959.       errMess:  CatTypes.String255;
  2960.       errLine: LONGINT;
  2961.       errRow : INTEGER;
  2962.       errWdw : INTEGER;
  2963.       i      : INTEGER;
  2964.       path, 
  2965.       name   : CatTypes.String255;
  2966. BEGIN
  2967.   i := 0;
  2968.   WHILE (i < errIndex) & (errFiles[i].wdw # wdw) DO INC (i) END;
  2969.   IF (i < errIndex) & 
  2970.      ParseErrLine (error, errMask, errF, errMess, errLine, errRow)
  2971.   THEN
  2972.     IF (LENGTH (errF) > 0) & CatEdit.FileIsEditor (errF, errWdw)
  2973.     THEN
  2974.       WdwManager.TopWindow (errWdw);
  2975.       CatEdit.SetError (errWdw, errLine, errRow, errMess, TRUE);
  2976.     ELSE
  2977.       IF LENGTH (errF) > 0
  2978.       THEN
  2979.         FileNames.SplitPath (errF, path, name);
  2980.         IF OpenEditor (path, name, errWdw, FALSE)
  2981.         THEN
  2982.           CatEdit.SetError (errWdw, errLine, errRow, errMess, TRUE);
  2983.         END;
  2984.       ELSE
  2985.         (* Kein File spezifiziert, in dem der Fehler auftrat. 
  2986.          * Das erstbeste Fenster nehmen
  2987.          *)
  2988.         WdwManager.GetOwnTopWindow (errWdw);
  2989.         IF ((errWdw # wdw) OR WdwManager.GetSecondWdw (errWdw))
  2990.            & CatEdit.IsEditTop (errWdw)
  2991.         THEN
  2992.           WdwManager.TopWindow (errWdw);
  2993.           CatEdit.SetError (errWdw, errLine, errRow, errMess, TRUE);
  2994.         END;
  2995.       END;
  2996.     END;
  2997.   END;
  2998. END handleErrorLine;
  2999.  
  3000. PROCEDURE hdlClose (wdw: INTEGER): BOOLEAN;
  3001.   VAR i, j : INTEGER;
  3002. BEGIN
  3003.   i := 0;
  3004.   WHILE (i < errIndex) & (errFiles[i].wdw # wdw) DO INC (i) END;
  3005.   IF i < errIndex 
  3006.   THEN
  3007.     FOR j := i+1 TO errIndex - 1 DO
  3008.       errFiles[j-1] := errFiles[j];
  3009.     END;
  3010.     DEC (errIndex);
  3011.   END;
  3012.   RETURN TRUE;
  3013. END hdlClose;
  3014.  
  3015. PROCEDURE OpenEditor (REF path, name: ARRAY OF CHAR; VAR wdw: INTEGER;
  3016.                       isErrFile: BOOLEAN): BOOLEAN;
  3017.   VAR i     : INTEGER;
  3018.       found : BOOLEAN;
  3019.       fname     : CatTypes.String255;
  3020.       varname   : CatTypes.String127;
  3021.       ext       : ARRAY [0..20] OF CHAR;
  3022.       tabs,
  3023.       margin    : INTEGER;
  3024.       succ,
  3025.       rtabs,
  3026.       wrap,
  3027.       errmode,
  3028.       doback    : BOOLEAN;
  3029. BEGIN
  3030.   (* Erstmal nachsehen, ob der Name auf eine der Extensions pažt *)
  3031.   i := 0; found := FALSE;
  3032.   Strings.Assign (name, fname, v.bool);
  3033.   Strings.Upper (fname);
  3034.   ConfVars.GetConfDefStr (cErrExtension, ext, '*.err');
  3035.   IF (WildCards.MatchName (fname, ext, TRUE) & (errIndex < maxErrFiles))
  3036.     OR isErrFile
  3037.   THEN
  3038.     tabs := 4; rtabs := TRUE;
  3039.     wrap := FALSE; margin := 255;
  3040.     doback := FALSE;
  3041.     errmode := TRUE;
  3042.   ELSE
  3043.     errmode := FALSE;
  3044.     WHILE (i <= 8) & ~found DO
  3045.       INC (i);
  3046.       buildVarName (cExtension, i, varname);
  3047.       IF ConfVars.GetConfigString (varname, ext) & (ext[0] # '')
  3048.       THEN
  3049.         found := WildCards.MatchName (fname, ext, TRUE)
  3050.       END;
  3051.     END;
  3052.     IF found
  3053.     THEN
  3054.       (* Ein paar Einstellung holen *)
  3055.       buildVarName (cExtTabsize, i, varname);
  3056.       ConfVars.GetConfDefInt (varname, tabs, 4);
  3057.       buildVarName (cExtHardTabs, i, varname);
  3058.       ConfVars.GetConfDefBool (varname, rtabs, FALSE);
  3059.       buildVarName (cExtWordWrap, i, varname);
  3060.       ConfVars.GetConfDefBool (varname, wrap, FALSE);
  3061.       buildVarName (cExtRightMargin, i, varname);
  3062.       ConfVars.GetConfDefInt (varname, margin, 255);
  3063.       buildVarName (cExtAutoBackup, i, varname);
  3064.       ConfVars.GetConfDefBool (varname, doback, FALSE);
  3065.     ELSE
  3066.       tabs := 4; rtabs := FALSE;
  3067.       wrap := FALSE; margin := 255;
  3068.       doback := FALSE;
  3069.     END;
  3070.   END;
  3071.   succ:= CatEdit.OpenEditor (path, name, FALSE, 
  3072.                              FALSE, NIL, NIL, NIL, ADDRESS(hdlClose), NIL, NIL, NIL, NIL, 
  3073.                              margin, TRUE, wrap, -1,
  3074.                              wdw);
  3075.   IF succ
  3076.   THEN
  3077.     CatEdit.SetMode (wdw, CatEdit.tabMode, rtabs);
  3078.     CatEdit.SetTabsize (wdw, tabs);
  3079.     CatEdit.SetMode (wdw, CatEdit.autoBackup, doback);
  3080.     IF errmode
  3081.     THEN
  3082.       v.bool := CatEdit.SetListProc (wdw, ADDRESS(handleErrorLine));
  3083.       CatEdit.SetListMode (wdw);
  3084.       IF errIndex < maxErrFiles
  3085.       THEN
  3086.         errFiles[errIndex].wdw := wdw;
  3087.         MagicStrings.Assign (path, errFiles[errIndex].fname);
  3088.         MagicStrings.Append (name, errFiles[errIndex].fname);
  3089.         INC (errIndex);
  3090.       END;
  3091.     END;
  3092.   END;
  3093.   RETURN succ;
  3094. END OpenEditor;
  3095.  
  3096. PROCEDURE doHelp (wdw : INTEGER; kstate : BITSET);
  3097. VAR buf    : POINTER TO ARRAY [0..$7FFF] OF CHAR;
  3098.     bufLen : LONGCARD;
  3099.     str    : ARRAY [0..7] OF CHAR;
  3100. BEGIN
  3101.   IF CatEdit.IsEditTop (wdw) 
  3102.   THEN
  3103.     IF ~CatEdit.BlockIsMarked (wdw) 
  3104.     THEN
  3105.       CatEdit.MarkWord (wdw);
  3106.     END;
  3107.     IF ~CatEdit.BlockIsMarked (wdw) 
  3108.     THEN
  3109.       str := "FRED";
  3110.       SendHelp (str);
  3111.       RETURN
  3112.     END;
  3113.     IF CatEdit.GetBlock (wdw, FALSE, FALSE, buf, bufLen) THEN 
  3114.       SendHelp (buf^);
  3115.       DEALLOCATE (buf, 0);
  3116.     END;
  3117.   END;
  3118. END doHelp;
  3119.  
  3120. PROCEDURE menuMsgHdler (item, title : CARDINAL; kstate : BITSET);
  3121. VAR res    : INTEGER;
  3122.     z, z2  : CARDINAL;
  3123.     message: ARRAY[0..40] OF CHAR;
  3124.     wild   : ARRAY[0..6] OF CHAR;
  3125.     hdl    : INTEGER;
  3126.     font,
  3127.     size   : INTEGER;
  3128.     wdw    : INTEGER;
  3129.     edWdw  : INTEGER;
  3130.     fselTitle : ARRAY [0..49] OF CHAR;
  3131.     
  3132.  
  3133.   PROCEDURE handleFSelMessage (item : CARDINAL);
  3134.   BEGIN
  3135.     wild := allWild;
  3136.     Strings.Assign(OpenName, InSel, v.bool);
  3137.     IF item = Fredrsc.Open THEN message := 'Datei laden';
  3138.     ELSIF item = Fredrsc.Readfile THEN message := 'Datei hinzuladen';
  3139.     END;
  3140.     IF FselGet(InPath, InSel, wild, message, FALSE) THEN
  3141.       Strings.Assign(InSel, OpenName, v.bool);
  3142.       IF (item = Fredrsc.Open)
  3143.       THEN
  3144.         IF OpenEditor (InPath, InSel, edWdw, FALSE)
  3145.         THEN
  3146.         END;
  3147.       ELSIF item = Fredrsc.Readfile THEN
  3148.         CatEdit.EditMerge(wdw, InPath, InSel);
  3149.       END
  3150.     END
  3151.   END handleFSelMessage;
  3152.  
  3153. BEGIN
  3154.   wdw := WdwManager.theTopWindow;
  3155.   IF ~mouse THEN mtAppl.MouseOn; mouse := TRUE; END;
  3156.   CASE item OF
  3157.     Fredrsc.About     : DoAbout; |
  3158.     Fredrsc.Newfile   : IF CatEdit.OpenEditor ('','', TRUE, 
  3159.                                              FALSE, NIL, NIL, NIL, NIL, NIL, NIL, NIL, NIL,
  3160.                                              maxLineLength, TRUE, FALSE, -1, edWdw)
  3161.                       THEN
  3162.                       END; |
  3163.     Fredrsc.Readfile,
  3164.     Fredrsc.Open      : handleFSelMessage (item); |
  3165.     Fredrsc.Infofile  : doFileInfos(wdw);         |
  3166.     Fredrsc.Closewdw  : IF CatEdit.CloseEditor (wdw, FALSE)
  3167.                         THEN
  3168.                         END; |
  3169.     Fredrsc.Abandon   : CatEdit.EditAbandonText (wdw); |                    
  3170.     Fredrsc.Savefile  : CatEdit.EditSave (wdw,'','', FALSE);   |
  3171.     Fredrsc.Saveas    : IF CatEdit.BlockIsMarked (wdw)
  3172.                         THEN
  3173.                           Strings.Assign (blockSaveAs, fselTitle, v.bool);
  3174.                         ELSE 
  3175.                           Strings.Assign (saveAs, fselTitle, v.bool); 
  3176.                         END;
  3177.                         IF FselGet(SavePath, SaveName, allWild, fselTitle, FALSE) 
  3178.                         THEN
  3179.                           CatEdit.EditSave(wdw, SavePath, SaveName, TRUE)
  3180.                         END;  |
  3181.     Fredrsc.Callshel  : DoShell()|
  3182.     Fredrsc.Printit   : CatEdit.EditPrint (wdw, CatEdit.BlockIsMarked (wdw)); |
  3183.     Fredrsc.Quitprog  : IF autoSavePos THEN CatEdit.EditSavePos(); END;
  3184.                         quitProg := CatEdit.CloseAllEditors(FALSE); |
  3185.     Fredrsc.Doundo    : CatEdit.DoUndo (wdw); |
  3186.     Fredrsc.Markall   : CatEdit.MarkAll (wdw); |
  3187.     Fredrsc.Bstartbl  : CatEdit.SetBlockStart (wdw); |
  3188.     Fredrsc.Bblend    : CatEdit.SetBlockEnd (wdw); |
  3189.     Fredrsc.Bcut      : v.bool := CatEdit.EditCut (wdw); |
  3190.     Fredrsc.Bcopy     : v.bool := CatEdit.EditCopy (wdw); |
  3191.     Fredrsc.Bpaste    : CatEdit.EditPaste (wdw); |
  3192.     Fredrsc.Bmove     : CatEdit.IndentBlock (wdw); |
  3193. (*    Fredrsc.Bswitch   : CatEdit.BlockSwap (wdw); |
  3194.     Fredrsc.Bupper    : CatEdit.BlockUp (wdw); |
  3195.     Fredrsc.Blower    : CatEdit.BlockDown (wdw); |
  3196.     Fredrsc.Bcapital  : CatEdit.BlockCapitals (wdw) |
  3197. *)
  3198.     Fredrsc.Bfilter   : ProcessFilter (wdw, TRUE); |
  3199.     Fredrsc.Sfind     : DoSearchDialogue(wdw); |
  3200.     Fredrsc.Sagain    : SearchAgain (wdw, kstate); |
  3201.     Fredrsc.Sfindsel  : SearchBlock (wdw, kstate); |
  3202.     Fredrsc.Sreplace  : DoReplaceDialogue(wdw); |
  3203.     Fredrsc.Sragain   : ReplaceAgain (wdw,kstate); |
  3204.     Fredrsc.Sblstart  : CatEdit.ToBlockStart (wdw); |
  3205.     Fredrsc.Sblend    : CatEdit.ToBlockEnd (wdw); |
  3206.     Fredrsc.Ssetmark  : GetOrSetMark (FALSE, wdw); |
  3207.     Fredrsc.Stomark   : GetOrSetMark (TRUE, wdw);  |
  3208.     Fredrsc.Stoerr    : CatEdit.ShowError (wdw); |
  3209.     Fredrsc.Stoline   : GetLine (wdw); |
  3210.     Fredrsc.Nextwdw   : WdwManager.TopNextWindow (); |
  3211.     Fredrsc.Wstacked  : WdwManager.ArrangeWindows (WdwManager.STACKED) |
  3212.     Fredrsc.Wneben    : WdwManager.ArrangeWindows (WdwManager.BYSIDE) |
  3213.     Fredrsc.Wstaffel  : WdwManager.ArrangeWindows (WdwManager.OVERLAP) |
  3214.     Fredrsc.Wtiled    : WdwManager.ArrangeWindows (WdwManager.TILED) |
  3215.     Fredrsc.Ofontsel  : DoSelectFont (wdw); |
  3216.     Fredrsc.Ofkeys    : doFloskel (); |
  3217.     Fredrsc.Otabs     : GetTabSize (wdw); |
  3218.     Fredrsc.Oerrfile  : doErrorBox (); |
  3219.     Fredrsc.Otabmode  : CatEdit.ToggleMode (wdw, CatEdit.tabMode); WdwManager.FullRedrawWdw (wdw); |
  3220.     Fredrsc.Oumbruch  : GetRightMargin (wdw); |
  3221.     Fredrsc.Opaths    : PListHelp.SelectPaths(pathBox); |
  3222.     Fredrsc.Oshorti   : doShortBox(); |
  3223.     Fredrsc.Oprinter  : doPrinter(); |
  3224.     Fredrsc.Oinsert   : CatEdit.ToggleMode (wdw, CatEdit.insMode) |
  3225.     Fredrsc.Oindent   : CatEdit.ToggleMode (wdw, CatEdit.indentMode) |
  3226.     Fredrsc.Oautosav  : autoSavePos := ~autoSavePos; 
  3227.                         v.bool := ConfVars.SetConfigBool (cAutoSavePrefs, autoSavePos); |
  3228.     Fredrsc.Osaveins  : SavePrefs(); |
  3229.     Fredrsc.Pcompile,
  3230.     Fredrsc.Pcompend,
  3231.     Fredrsc.Pcomprun,
  3232.     Fredrsc.Pmake,
  3233.     Fredrsc.Pmakerun  : hdlComp (item, wdw) |
  3234.   ELSE
  3235.   END;
  3236.   MagicAES.MenuTnormal(menu, title, MagicAES.Set)
  3237. END menuMsgHdler;
  3238.  
  3239. (*----------------------------------------------*)
  3240. PROCEDURE clickHandler (x, y : INTEGER; Button: BITSET; Clicks: INTEGER; kstate : BITSET);
  3241.   VAR wdw   : INTEGER;
  3242.       res   : INTEGER;
  3243.       popStr: ARRAY [0..79] OF CHAR;
  3244. BEGIN
  3245.   IF (1 IN Button) & ~(0 IN Button)
  3246.   THEN
  3247.     WdwManager.ClickInWindow (x, y, wdw);
  3248.     IF wdw >= 0
  3249.     THEN
  3250.       IF CatEdit.IsEditTop (wdw)
  3251.        & ~CatEdit.GetMode (wdw, CatEdit.errorMode)
  3252.        & CatEdit.ClickIsInBlock (wdw, x, y)
  3253.        & (Clicks = 1)
  3254.       THEN
  3255.         (* Normaler Editor ist Top *)
  3256.         popStr := " Ausschneiden | Kopieren | Filtern... ";
  3257.         res := mtPopups.PosPopup (x, y, popStr, "");
  3258.         CASE res OF
  3259.           0: v.bool := CatEdit.EditCut (wdw); |
  3260.           1: v.bool := CatEdit.EditCopy (wdw); |
  3261.           2: ProcessFilter (wdw, FALSE); |
  3262.         ELSE
  3263.         END;
  3264.       END;
  3265.     END;
  3266.   END;
  3267. END clickHandler;
  3268.  
  3269.  
  3270. PROCEDURE keyHdler (scan, ch : CHAR; moKState : BITSET);
  3271. CONST
  3272.       helpScan     = 142C;
  3273.   VAR wdw : INTEGER;
  3274.       num : INTEGER;
  3275.       varName : ARRAY[0..20] OF CHAR;
  3276.       val     : ARRAY [0..511] OF CHAR;
  3277.       aktion,
  3278.       fname   : BOOLEAN;
  3279.       msg     : INTEGER;
  3280. BEGIN
  3281.   wdw := WdwManager.theTopWindow;
  3282.   IF (scan >= 73C) & (scan <= 104C) THEN
  3283.     (* F1 bis F10 *)
  3284.     IF ~mouse THEN
  3285.       mtAppl.MouseOn; mouse := TRUE;
  3286.     END;
  3287.     IF (moKState = {}) & CatEdit.IsEditTop (wdw)
  3288.     THEN
  3289.       num := ORD(scan) - 59 + 1;
  3290.       Strings.Assign (cNormalFkey, varName, v.bool);
  3291.       Strings.Append (StrConv.IntToStr (num,0), varName, v.bool);
  3292.       IF ConfVars.GetConfigString (varName, val)
  3293.       THEN
  3294.         v.bool := CatEdit.PutLine (WdwManager.theTopWindow, ADR(val), LENGTH (val));
  3295.       END;
  3296.     END;
  3297.   ELSIF (scan >= 124C) & (scan <= 135C)
  3298.   THEN
  3299.     (* Shift-F1 bis F10 *)
  3300.     IF CatEdit.IsEditTop (wdw) & 
  3301.        ~(MagicAES.KALT IN moKState) & 
  3302.         ~(MagicAES.KCTRL IN moKState)
  3303.     THEN
  3304.       (* mit Shift! *)
  3305.       num := ORD(scan) - 84 + 1;
  3306.       Strings.Assign (cShiftFkey, varName, v.bool);
  3307.       Strings.Append (StrConv.IntToStr (num,0), varName, v.bool);
  3308.       IF ConfVars.GetConfigString (varName, val)
  3309.       THEN
  3310.         v.bool := CatEdit.PutLine (WdwManager.theTopWindow, ADR(val), LENGTH (val));
  3311.       END;
  3312.     END;
  3313.   ELSIF (scan = helpScan)
  3314.   THEN
  3315.     doHelp (WdwManager.theTopWindow, moKState);
  3316.   ELSIF MagicAES.KCTRL IN moKState
  3317.   THEN
  3318.     (* Test auf Ctrl-1 bis Ctrl^7 auf dem Ziffernblock *)
  3319.     aktion := TRUE;
  3320.     fname  := FALSE;
  3321.     CASE scan OF 
  3322.     (*  147C: (* Num-7 *)
  3323.             msg := SEProto.ES_PROJECT; *)
  3324.       152C: (* Num-4 *)
  3325.             msg := SEProto.ES_MAKEALL;
  3326.     | 153C: (* Num-5 *)
  3327.             msg := SEProto.ES_EXEC;
  3328.             fname := TRUE;
  3329.     | 154C: (* Num-6 *)
  3330.             msg := SEProto.ES_MAKEEXEC;
  3331.     | 155C: (* Num-1 *)
  3332.             msg := SEProto.ES_COMPILE;
  3333.             fname := TRUE;
  3334.     | 156C: (* Num-2 *)
  3335.             msg := SEProto.ES_LINK;
  3336.             fname := TRUE;
  3337.     | 157C: (* Num-3 *)
  3338.             msg := SEProto.ES_MAKE;
  3339.     ELSE
  3340.       aktion := FALSE;
  3341.     END;
  3342.     IF aktion
  3343.     THEN
  3344.       IF fname 
  3345.       THEN
  3346.         (* Filenamen von TopWindow erfragen *)
  3347.         IF CatEdit.GetCompInfo (wdw, val, fname)
  3348.         THEN
  3349.           IF ~fname THEN 
  3350.             CatEdit.AskForSave (wdw);
  3351.           END;
  3352.           SendEsMessage (msg, ADR(val));
  3353.         END;
  3354.       ELSE
  3355.         SendEsMessage (msg, NIL);
  3356.       END;
  3357.     END;
  3358.   END;
  3359. END keyHdler;
  3360.  
  3361. PROCEDURE OnlyWildcards (name: ARRAY OF CHAR): BOOLEAN;
  3362.   VAR i, l : INTEGER;
  3363. BEGIN
  3364.   l := LENGTH (name);
  3365.   i := 0;
  3366.   WHILE i < l DO
  3367.     IF ~(name[i] IN CatTypes.charSet {'*','?','.'})
  3368.     THEN RETURN FALSE
  3369.     END;
  3370.     INC (i);
  3371.   END;
  3372.   RETURN TRUE;
  3373. END OnlyWildcards;
  3374.  
  3375. PROCEDURE msgHandler (buffAdr: ADDRESS; kstate: BITSET): BOOLEAN;
  3376.   VAR ch, scan : CHAR;
  3377.       moKState : BITSET;
  3378.       kReturn  : INTEGER;
  3379.       pName, pCmd : CatTypes.Str255Ptr;
  3380.       eMess: CatTypes.String255;
  3381.       path : CatTypes.pathStrType;
  3382.       name : CatTypes.nameStrType;
  3383.       suff : CatTypes.extStrType;
  3384.       access: SEProto.tPtrMessRec;
  3385.       errPtr: SEProto.tPtrErrInfo;
  3386.       errWdw: INTEGER;
  3387.       pBuff : POINTER TO ARRAY [0..9] OF INTEGER;
  3388.       handled: BOOLEAN;
  3389. BEGIN
  3390.   handled := TRUE;
  3391.   pBuff := buffAdr;
  3392.   CASE IsProtokoll(pBuff, kReturn, moKState, pName, pCmd) OF
  3393.     rNoproto : |
  3394.     rNone    : |
  3395.     rChar    : SplitWordToByte(kReturn, scan, char);
  3396.                IF MenuSearch(menu, mtAppl.ApplIdent, moKState, kReturn,
  3397.                              menuMsgHdler, ~mouse) THEN
  3398.                  mouse := TRUE;
  3399.                  event := event - {MagicAES.MUKEYBD}; (* kein Keyboard *)
  3400.                ELSE
  3401.                  keyHdler (scan, char, moKState);
  3402.                END; |
  3403.     (* Anderer Tastendruck wird evtl. bergemangelt.. *)
  3404.     rText    : ; |
  3405.     rStart   : (*
  3406.                mtDir.SplitPath(pName^, path, name, suff);
  3407.                IF (pCmd # NIL) THEN
  3408.                  v.int := StartPrg(path, name, pCmd^, TRUE)
  3409.                ELSE
  3410.                  suff := '';
  3411.                  v.int := StartPrg(path, name, suff, TRUE)
  3412.                END *) |
  3413.     rOpen    : (* Entweder AV_OPENWIND oder VA_START. Bei VA_START ist pName NIL!,
  3414.                 * und in pCmd steht eine Kommandozeile. Bei OpenWind steht in pName 
  3415.                 * der Pfad und in pCmd ein Dateiname.
  3416.                 *)
  3417.                IF pName # NIL
  3418.                THEN
  3419.                  (* AV_OPENWIND: Editor mit Datei ”ffnen *)
  3420.                  IF OnlyWildcards(pCmd^)
  3421.                  THEN
  3422.                    MagicStrings.Assign (pName^, InPath);
  3423.                    MagicStrings.Assign ('', InSel);
  3424.                    IF FselGet(InPath, InSel, '*.*', 'Datei laden', FALSE) 
  3425.                    THEN
  3426.                      Strings.Assign(InSel, OpenName, v.bool);
  3427.                      v.bool := OpenEditor (InPath, InSel, v.int, FALSE);
  3428.                    END;
  3429.                  ELSE
  3430.                    v.bool := OpenEditor (pName^, pCmd^, v.int, FALSE);
  3431.                  END;
  3432.                ELSE
  3433.                  (* VA_START: pCmd enth„lt Kommandozeile *)
  3434.                  IF MagicStrings.Length (pCmd^) > 0
  3435.                  THEN
  3436.                    (* Jetzt Kommandozeile auswerten: 
  3437.                     * entweder ist ein Dateiname enthalten oder sie f„ngt mit 
  3438.                     * - an und ist eine Kommandoliste
  3439.                     *)
  3440.                    IF CatEdit.FileIsEditor (pCmd^, errWdw)
  3441.                    THEN
  3442.                      WdwManager.TopWindow (errWdw);
  3443.                    ELSE
  3444.                      FileNames.SplitPath (pCmd^, InPath, OpenName);
  3445.                      v.bool := OpenEditor (InPath, OpenName, v.int, FALSE);
  3446.                    END;
  3447.                  END;
  3448.                END; |
  3449.     rSeMess  : access := buffAdr;
  3450.                CASE access^.msg OF
  3451.                  SEProto.SE_ERROR   : (* Fehler auswerten *)
  3452.                               WITH access^.errorPtr^ DO
  3453.                                 IF errMess # NIL
  3454.                                 THEN
  3455.                                   MagicStrings.Assign (errMess^, eMess);
  3456.                                 ELSE
  3457.                                   MagicStrings.Assign ('Keine Fehlermeldung erhalten', eMess);
  3458.                                 END;
  3459.                                 IF errFile # NIL
  3460.                                 THEN
  3461.                                   IF CatEdit.FileIsEditor (errFile^, errWdw)
  3462.                                   THEN
  3463.                                     WdwManager.TopWindow (errWdw);
  3464.                                     CatEdit.SetError (errWdw, errLine, errRow-1, eMess, TRUE);
  3465.                                   ELSE
  3466.                                     FileNames.SplitPath (errFile^, path, name);
  3467.                                     IF OpenEditor (path, name, errWdw, FALSE)
  3468.                                     THEN
  3469.                                       CatEdit.SetError (errWdw, errLine, errRow-1, eMess, TRUE);
  3470.                                     END;
  3471.                                   END;
  3472.                                 END;
  3473.                               END; |
  3474.                  SEProto.SE_ERRFILE : 
  3475.                               WITH access^ DO
  3476.                                 IF fnamePtr # NIL
  3477.                                 THEN
  3478.                                   IF ~CatEdit.FileIsEditor (fnamePtr^, errWdw)
  3479.                                   THEN
  3480.                                     FileNames.SplitPath (fnamePtr^, path, name);
  3481.                                     v.bool := OpenEditor (path, name, errWdw, FALSE)
  3482.                                   END;
  3483.                                 END;
  3484.                                 IF errPtr # NIL
  3485.                                 THEN
  3486.                                   FileNames.SplitPath (errPtr^, path, name);
  3487.                                   v.bool := OpenEditor (path, name, errWdw, TRUE)
  3488.                                 END;
  3489.                               END; |
  3490.                  SEProto.SE_TERMINATE: (* Wir tun einfach so, als h„tten wir ein APTERM erhalten *)
  3491.                                pBuff^[0] := MagicAES.APTERM ; |
  3492.                  SEProto.SE_CLOSE:     
  3493.                                v.bool := CatEdit.CloseAllEditors(TRUE); |
  3494.                ELSE
  3495.                END;
  3496.   ELSE
  3497.     handled := FALSE;
  3498.   END;
  3499.   IF pBuff^[0] = MagicAES.MNSELECTED
  3500.   THEN
  3501.     event := event - {MagicAES.MUBUTTON}; (* keine Buttons *)
  3502.     menuMsgHdler(pBuff^[4], pBuff^[3], kstate);
  3503.     handled := TRUE;
  3504.   ELSIF pBuff^[0] = MagicAES.APTERM 
  3505.   THEN 
  3506.     quitProg := TRUE; 
  3507.     IF autoSavePos THEN CatEdit.EditSavePos(); END;
  3508.     v.bool := CatEdit.CloseAllEditors(TRUE);
  3509.     handled := TRUE;
  3510.   END;
  3511.   RETURN handled;
  3512. END msgHandler;
  3513.  
  3514. TYPE mSet = SET OF [0..255];
  3515.  
  3516. VAR menuSet : mSet;
  3517.  
  3518. PROCEDURE enableMenuItems();
  3519.  
  3520.   PROCEDURE EnableItem (tree : ADDRESS; item : INTEGER; enable : BOOLEAN);
  3521.   BEGIN
  3522.     IF enable
  3523.     THEN
  3524.       IF ~(item IN menuSet) THEN 
  3525.         MagicAES.MenuIenable (menu, item, 1); 
  3526.         INCL(menuSet, item);
  3527.       END;
  3528.     ELSE
  3529.       IF item IN menuSet THEN 
  3530.         MagicAES.MenuIenable (menu, item, 0); 
  3531.         EXCL(menuSet, item);
  3532.       END;
  3533.     END;
  3534.   END EnableItem;
  3535.  
  3536.   PROCEDURE CheckItem (tree : ADDRESS; item : INTEGER; enable : BOOLEAN);
  3537.   BEGIN
  3538.     IF enable
  3539.     THEN
  3540.       MagicAES.MenuIcheck (menu, item, 1);
  3541.     ELSE
  3542.       MagicAES.MenuIcheck (menu, item, 0);
  3543.     END;
  3544.   END CheckItem;
  3545.  
  3546.   VAR wdw : INTEGER;
  3547.       bl,
  3548.       isTop,
  3549.       moreWinds,
  3550.       twoWinds : BOOLEAN;
  3551. BEGIN
  3552.   wdw := WdwManager.theTopWindow;
  3553.   bl := CatEdit.BlockIsMarked (wdw);
  3554.   isTop := CatEdit.IsEditTop (wdw);
  3555.   moreWinds := WdwManager.TopNextPossible(); 
  3556.   twoWinds := WdwManager.TopNextPossible();
  3557.  
  3558.   EnableItem (menu, Fredrsc.Readfile, isTop);    (* STRING in Baum MENU *)
  3559.   EnableItem (menu, Fredrsc.Infofile, isTop);    (* STRING in Baum MENU *)
  3560.   EnableItem (menu, Fredrsc.Closewdw, isTop);    (* STRING in Baum MENU *)
  3561.   EnableItem (menu, Fredrsc.Abandon , isTop);    (* STRING in Baum MENU *)
  3562.   EnableItem (menu, Fredrsc.Savefile, isTop);    (* STRING in Baum MENU *)
  3563.   EnableItem (menu, Fredrsc.Saveas  , isTop);    (* STRING in Baum MENU *)
  3564.   EnableItem (menu, Fredrsc.Printit , isTop);    (* STRING in Baum MENU *)
  3565.   EnableItem (menu, Fredrsc.Markall , isTop);    (* STRING in Baum MENU *)
  3566.   EnableItem (menu, Fredrsc.Bstartbl, isTop);    (* STRING in Baum MENU *)
  3567.   EnableItem (menu, Fredrsc.Bblend  , isTop);    (* STRING in Baum MENU *)
  3568.   EnableItem (menu, Fredrsc.Bcut    , bl);       (* STRING in Baum MENU *)
  3569.   EnableItem (menu, Fredrsc.Bcopy   , bl);       (* STRING in Baum MENU *)
  3570.   EnableItem (menu, Fredrsc.Bpaste  , isTop);    (* STRING in Baum MENU *)
  3571.   EnableItem (menu, Fredrsc.Bmove   , bl);       (* STRING in Baum MENU *)
  3572.   EnableItem (menu, Fredrsc.Bfilter , bl);       (* STRING in Baum MENU *)
  3573.  
  3574.   EnableItem (menu, Fredrsc.Sfind   , isTop);    (* STRING in Baum MENU *)
  3575.   EnableItem (menu, Fredrsc.Sagain  , isTop & searchOpts.isSet);    (* STRING in Baum MENU *)
  3576.   EnableItem (menu, Fredrsc.Sreplace, isTop);    (* STRING in Baum MENU *)
  3577.   EnableItem (menu, Fredrsc.Sfindsel, isTop);    (* STRING in Baum MENU *)
  3578.   EnableItem (menu, Fredrsc.Sragain , isTop & replaceOpts.isSet);    (* STRING in Baum MENU *)
  3579.   EnableItem (menu, Fredrsc.Sblstart, bl);       (* STRING in Baum MENU *)
  3580.   EnableItem (menu, Fredrsc.Sblend  , bl);       (* STRING in Baum MENU *)
  3581.   EnableItem (menu, Fredrsc.Ssetmark, isTop);    (* STRING in Baum MENU *)
  3582.   EnableItem (menu, Fredrsc.Stomark , isTop);    (* STRING in Baum MENU *)
  3583.   EnableItem (menu, Fredrsc.Stoline , isTop);    (* STRING in Baum MENU *)
  3584.   EnableItem (menu, Fredrsc.Stoerr  , isTop);    (* STRING in Baum MENU *)
  3585.   EnableItem (menu, Fredrsc.Nextwdw , moreWinds);   (* STRING in Baum MENU *)
  3586.   EnableItem (menu, Fredrsc.Wstacked, twoWinds);    (* STRING in Baum MENU *)
  3587.   EnableItem (menu, Fredrsc.Wneben  , twoWinds);    (* STRING in Baum MENU *)
  3588.   EnableItem (menu, Fredrsc.Wstaffel, twoWinds);    (* STRING in Baum MENU *)
  3589.   EnableItem (menu, Fredrsc.Wtiled  , twoWinds);    (* STRING in Baum MENU *)
  3590.   EnableItem (menu, Fredrsc.Ofontsel, isTop);       (* STRING in Baum MENU *)
  3591.   (*
  3592.   EnableItem (menu, Fredrsc.Otabs   , isTop);       (* STRING in Baum MENU *)
  3593.   *)
  3594.  
  3595.   EnableItem (menu, Fredrsc.Oumbruch, isTop);      (* STRING in Baum MENU *)
  3596.   EnableItem (menu, Fredrsc.Otabmode, isTop);      (* STRING in Baum MENU *)
  3597.   (*
  3598.   EnableItem (menu, Fredrsc.Obackup , isTop);      (* STRING in Baum MENU *)
  3599.   *)
  3600.   EnableItem (menu, Fredrsc.Oinsert , isTop);      (* STRING in Baum MENU *)
  3601.   EnableItem (menu, Fredrsc.Oindent , isTop);      (* STRING in Baum MENU *)
  3602.   IF isTop
  3603.   THEN
  3604.     CheckItem (menu, Fredrsc.Otabmode, CatEdit.GetMode(wdw, CatEdit.tabMode));         (* STRING in Baum MENU *)
  3605.     (*
  3606.     CheckItem (menu, Fredrsc.Obackup , CatEdit.GetMode(wdw, CatEdit.autoBackup));      (* STRING in Baum MENU *)
  3607.     *)
  3608.     CheckItem (menu, Fredrsc.Oinsert , CatEdit.GetMode(wdw, CatEdit.insMode));         (* STRING in Baum MENU *)
  3609.     CheckItem (menu, Fredrsc.Oindent , CatEdit.GetMode(wdw, CatEdit.indentMode));      (* STRING in Baum MENU *)
  3610.   END;
  3611.   
  3612.   EnableItem (menu, Fredrsc.Pcompile, isTop & (mm2shell OR SEProtoActiv ()));    (* STRING in Baum MENU *)
  3613.   EnableItem (menu, Fredrsc.Pcompend, isTop);    (* STRING in Baum MENU *)
  3614.   EnableItem (menu, Fredrsc.Pcomprun, isTop);    (* STRING in Baum MENU *)
  3615.   EnableItem (menu, Fredrsc.Pmake   , isTop);    (* STRING in Baum MENU *)
  3616.   EnableItem (menu, Fredrsc.Pmakerun, isTop);    (* STRING in Baum MENU *)
  3617.  
  3618.   CheckItem (menu, Fredrsc.Oautosav , autoSavePos);(* STRING in Baum MENU *)
  3619. END enableMenuItems;
  3620.  
  3621. VAR crash : BOOLEAN;
  3622.  
  3623. (* Hier kommt jetzt der Crash-Handler *)
  3624. PROCEDURE crashHandler;
  3625.   (* Wird automatisch bei Terminierung des Programms aufgerufen *)
  3626.   VAR entry : CatTypes.Str255Ptr;
  3627. BEGIN
  3628.   IF MOSCtrl.ModLevel # 1
  3629.   THEN
  3630.     (* Pfadliste l”schen *)
  3631.     Lists.ResetList (ShellMsg.SrcPaths);
  3632.     entry := Lists.NextEntry (ShellMsg.SrcPaths);
  3633.     WHILE entry # NIL DO
  3634.       Lists.RemoveEntry (ShellMsg.SrcPaths,v.bool);
  3635.       DEALLOCATE (entry, 0);
  3636.       entry := Lists.NextEntry (ShellMsg.SrcPaths);
  3637.     END;
  3638.     ShellMsg.SrcPaths := oldSrcPaths;
  3639.   END;
  3640.   mtAppl.MouseOn();
  3641.   v.int := MagicAES.MenuBar(menu, MagicAES.Reset);
  3642.   v.bool := CatEdit.CloseAllEditors(FALSE);
  3643.   MagicAES.RsrcFree();
  3644.   SendTerminate();
  3645.   MagicAES.WindUpdate(MagicAES.ENDUPDATE);
  3646.   mtAppl.ApplTerm(termCode); 
  3647. END crashHandler;
  3648.  
  3649. PROCEDURE isFilename (REF s : ARRAY OF CHAR): BOOLEAN;
  3650.   VAR p,f :ARRAY [0..139] OF CHAR;
  3651.       i : INTEGER;
  3652. BEGIN
  3653.   i := 0;
  3654.   i := Strings.Pos ('.',s,0);
  3655.   IF i > 0 THEN RETURN TRUE END;
  3656.   i := Strings.Pos ('\',s,0);
  3657.   IF i > 0 THEN RETURN TRUE END;
  3658.   i := Strings.Pos (':',s,0);
  3659.   IF i > 0 THEN RETURN TRUE END;
  3660.   RETURN FALSE
  3661. END isFilename;
  3662.  
  3663. PROCEDURE isNumber (REF s : ARRAY OF CHAR):BOOLEAN;
  3664.   VAR i : LONGINT;
  3665.       j : CARDINAL;
  3666. BEGIN
  3667.   j := 0;
  3668.   i := StrConv.StrToLInt(s,j,v.bool);
  3669.   RETURN v.bool
  3670. END isNumber;
  3671.  
  3672. VAR stck: MemArea;
  3673.     rHdl: TermCarrier;
  3674.     resName : ARRAY [0..79] OF CHAR;
  3675.     wdw : INTEGER; 
  3676.     eLine : LONGINT;
  3677.     eRow  : INTEGER;
  3678.     eMsg  : ARRAY [0..79] OF CHAR;
  3679.     fullName,
  3680.     path,
  3681.     name,
  3682.     para  : ARRAY [0..139] OF CHAR;
  3683.     firstNumber,
  3684.     allSet,
  3685.     numberRead : BOOLEAN;
  3686.     p          : CARDINAL;
  3687.     i, 
  3688.     params     : INTEGER;
  3689.     topVdi     : INTEGER;
  3690.     
  3691.     multiTasking : BOOLEAN;
  3692.     multiTOS     : BOOLEAN;
  3693.     magixCookie  : magixCookiePtr;
  3694.     isMagiX      : BOOLEAN;
  3695.     started      : BOOLEAN;
  3696.     otherId      : INTEGER;
  3697.     apName       : PtrMaxStr;
  3698.  
  3699. PROCEDURE FindOtherFred (VAR otherId : INTEGER) : BOOLEAN;
  3700.   VAR appName : MaxStr;
  3701.       i       : INTEGER;
  3702. BEGIN
  3703. (*
  3704.   IF isMagiX
  3705.   THEN
  3706.   
  3707.     Strings.Assign ('fred.prg', appName, v.bool);
  3708.     otherId := MagicAES.ApplFind (ADR(appName));
  3709.     IF otherId = mtAppl.ApplIdent
  3710.     THEN
  3711.       appName[0] := '?';
  3712.       appName[1] := 0C;
  3713.       appName[3] := 0C;
  3714.       FOR i := otherId+1 TO MagicAES.AESGlobal.apCount-1 DO
  3715.         appName[2] := CHR(i);
  3716.         IF (MagicAES.ApplFind (ADR(appName)) # 0) & 
  3717.             Strings.StrEqual ('FRED.PRG', appName)
  3718.         THEN
  3719.           RETURN TRUE
  3720.         END;
  3721.       END;
  3722.     ELSE
  3723.       RETURN TRUE
  3724.     END;
  3725.   ELSE
  3726.   *)
  3727.     (* MultiTOS *)
  3728.     FOR i := 0 TO 12 DO appName[i] := 0C; END;
  3729.     IF MagicAES.ApplSearch (MagicAES.APFIRST, appName, v.int, otherId)
  3730.     THEN
  3731.       REPEAT 
  3732.         Strings.DelTrailingBlanks (appName);
  3733.         IF (otherId # mtAppl.ApplIdent) & 
  3734.             Strings.StrEqual(appName, 'FRED')
  3735.         THEN
  3736.           RETURN TRUE
  3737.         END;
  3738.         FOR i := 0 TO 12 DO appName[i] := 0C; END;
  3739.       UNTIL ~MagicAES.ApplSearch (MagicAES.APNEXT, appName, v.int, otherId);
  3740.     END;
  3741. (*  END; *)
  3742.   RETURN FALSE;
  3743. END FindOtherFred;
  3744.  
  3745. (*$L-,R-,S-*)
  3746. PROCEDURE sigHandler();
  3747. BEGIN
  3748.   ASSEMBLER
  3749.     MOVE.W  #0,termCode
  3750.     MOVE.W  #TRUE,quitProg
  3751.   END;
  3752. END sigHandler;
  3753. (*$L=,R=,S=*)
  3754.  
  3755. PROCEDURE installSignalHandler();
  3756. BEGIN
  3757.   IF MintUtil.IsMiNT()
  3758.   THEN
  3759.     (* Folgende Signale werden abgefangen und ignoriert:
  3760.      * SIGHUP, SIGINT, SIGSYS, 
  3761.      *)
  3762.     v.lbset := Mintbind.Psigblock (MagicSys.lBITSET{Mintbind.SIGHUP, Mintbind.SIGINT, Mintbind.SIGSYS});
  3763.     (* Folgende Signale werden mit Programmterminierung befolgt:
  3764.      * SIGQUIT, SIGPIPE, SIGTERM, SIGXCPU
  3765.      * Dabei ist es mir egal, ob die Installation geklappt hat oder nicht.
  3766.      *)
  3767.     v.a := Mintbind.Psignal (Mintbind.SIGTERM, ADDRESS (sigHandler));
  3768.     v.a := Mintbind.Psignal (Mintbind.SIGQUIT, ADDRESS (sigHandler));
  3769.     v.a := Mintbind.Psignal (Mintbind.SIGPIPE, ADDRESS (sigHandler));
  3770.     v.a := Mintbind.Psignal (Mintbind.SIGXCPU, ADDRESS (sigHandler));
  3771.   END;
  3772. END installSignalHandler;
  3773.  
  3774. PROCEDURE handleEvents ();
  3775. BEGIN
  3776.   ClearBuffer(event, FALSE, moKState, ORD(SCAN), CH);
  3777.  
  3778.   IF MagicAES.MUKEYBD IN event THEN (* Keyboard - MenuKommandos*)
  3779.     IF MenuSearch(menu, mtAppl.ApplIdent, moKState, kReturn,
  3780.                   menuMsgHdler, ~mouse) THEN
  3781.       mouse := TRUE; (* Wird dann in MenuSearch gemacht *)
  3782.       event := event - {MagicAES.MUKEYBD}; (* kein Keyboard *)
  3783.     END;
  3784.   END;
  3785.   IF MagicAES.MUBUTTON IN event
  3786.   THEN
  3787.     IF ~mouse THEN
  3788.       mtAppl.MouseOn; mouse := TRUE; (*
  3789.       MagicAES.GrafMouse(MagicAES.MON, NIL); mouse := TRUE *)
  3790.     END;
  3791.     (* Warten auf loslassen oder waitingTime *)
  3792.     e := MagicAES.EvntMulti(
  3793.                {MagicAES.MUBUTTON, MagicAES.MUTIMER},
  3794.                 0,{1,0},{}, 0,dr, 0,dr, mess, 100, 0,
  3795.                 v.int, v.int, v.bset, v.int, v.bset, v.int, v.char, v.int);
  3796.   END;
  3797.   IF WdwManager.HandleEvent (event, mess, moButton, moKState, char, scan, kReturn, moX, moY, bReturn)
  3798.   THEN
  3799.   END;
  3800.   IF MagicAES.MUMESAG IN event THEN
  3801.     v.bool := msgHandler (ADR(mess), moKState);
  3802.     event := event - {MagicAES.MUBUTTON};
  3803.     (* nicht gleichzeitig Button und Message! *)
  3804.   END;
  3805.  
  3806.   IF MagicAES.MUM1 IN event THEN
  3807.     IF ~mouse THEN
  3808.       mtAppl.MouseOn; mouse := TRUE;
  3809.     END;
  3810.   END;
  3811.  
  3812.   IF MagicAES.MUBUTTON IN event THEN (* Button *)
  3813.     clickHandler (moX, moY, moButton, bReturn, moKState);
  3814.   END;
  3815.  
  3816.   IF MagicAES.MUKEYBD IN event THEN (* Keyboard - kann eigentlich nur noch F-Taste sein *)
  3817.     keyHdler (scan, char, moKState);
  3818.   END;
  3819. END handleEvents;
  3820.  
  3821. PROCEDURE handlePendingEvents();
  3822.   VAR etv : BITSET;
  3823. BEGIN
  3824.   REPEAT
  3825.     event := MagicAES.EvntMulti(
  3826.                    {MagicAES.MUMESAG, MagicAES.MUTIMER},
  3827.                     0, {},{}, 0, dr, 0, dr, mess, 50, 0,
  3828.                     v.int, v.int, v.bset, v.int, v.bset, v.int, v.char, v.int);
  3829.     etv := event;
  3830.     IF MagicAES.MUMESAG IN event
  3831.     THEN
  3832.       MagicAES.WindUpdate(MagicAES.BEGUPDATE);
  3833.       handleEvents();
  3834.       MagicAES.WindUpdate(MagicAES.ENDUPDATE);
  3835.     END;
  3836.   UNTIL ~(MagicAES.MUMESAG IN etv);
  3837. END handlePendingEvents;
  3838.  
  3839. BEGIN
  3840.   CatGlobal.isMintDomain := Mintbind.Pdomain (1) = 0;
  3841.   filterNumber := 0;
  3842.   shortFileRead := FALSE;
  3843.   searchOpts.isSet := FALSE;
  3844.   replaceOpts.isSet := FALSE;
  3845.   installSignalHandler();
  3846.   CatchProcessTerm (rHdl, crashHandler, stck);
  3847.  
  3848. (* Hier kann man sich ein:  mtAppl.ApplInit(); denken   *)
  3849. (* Es wird automatisch ausgefhrt..                     *)
  3850.  
  3851.   errIndex := 0;
  3852.  
  3853.   mtAppl.MouseBusy;
  3854.   termCode := 0;
  3855.   mm2shell :=  MOSCtrl.ModLevel # 1;
  3856.   multiTasking := MagicAES.AESGlobal.apCount # 1;
  3857.   isMagiX := FALSE;
  3858.   multiTOS := (MagicAES.AESGlobal.apVersion >= $400)
  3859.             & multiTasking;
  3860.   IF MagicCookie.FindCookie ('MagX', magixCookie)
  3861.   THEN
  3862.     isMagiX := magixCookie^.aesVars # ADDRESS(0L);
  3863.   END;
  3864.   resName := 'fred.rsc';
  3865.   IF InitResource (resName)
  3866.   THEN
  3867.     menuSet := mSet {0..255};
  3868.     shellCommand := "";
  3869.     
  3870.     ConfVars.GetConfDefBool (cAutoSavePrefs, autoSavePos, FALSE);
  3871.  
  3872.     mtAlerts.ConfigAlert (mtAlerts.alticon);
  3873.  
  3874.     MagicAES.WindUpdate(MagicAES.BEGUPDATE);
  3875.     IF multiTOS THEN 
  3876.       apName := CADR (eddixName);
  3877.       v.int := MagicAES.MenuRegister (mtAppl.ApplIdent, apName^);
  3878.       (* Und auch Bescheid sagen, daž wir AP_TERM verstehen *)
  3879.       v.int := MagicAES.ShelWrite (MagicAES.InformAES, INTEGER(BITSET{MagicAES.ApTermBit}), 0, "", "");
  3880.     END;
  3881.     v.int := MagicAES.MenuBar(menu, MagicAES.Set);    (* show our menubar   *)
  3882.     
  3883.     mtDials.DialConfig (mtDials.UseConfig, FALSE);
  3884.  
  3885. (* ---------------------------------------------------------------------- *)
  3886.  
  3887.     (* Parameter holen und auswerten *)
  3888.     firstNumber := TRUE;
  3889.     numberRead := FALSE;
  3890.     allSet := FALSE;
  3891.     wdw := -1;
  3892.     params := mtCommand.ParamCount();
  3893.     i := 1;
  3894.     eMsg := "";
  3895.     started := FALSE;
  3896.     WHILE params > 0 DO 
  3897.       mtCommand.ParamString (i,para);
  3898.       IF isFilename (para)
  3899.       THEN
  3900.         Strings.Assign (para, fullName, v.bool);
  3901.         FileNames.SplitPath (fullName, path, name);
  3902.         IF multiTasking & FindOtherFred (otherId)
  3903.         THEN
  3904.           SendOpenwind (otherId, ADR(path), ADR(name));
  3905.           MagicAES.WindUpdate (MagicAES.ENDUPDATE);
  3906.           started := FALSE;
  3907.           REPEAT
  3908.             event := MagicAES.EvntMulti(
  3909.                      {MagicAES.MUTIMER, MagicAES.MUMESAG},
  3910.                       0, {0},{0}, MagicAES.LeaveRect, mrect, 0,dr, mess, 500, 0,
  3911.                       moX, moY, moButton, kReturn, moKState, SCAN, CH, bReturn);
  3912.             (* Timeout 500 ms *)
  3913.             IF (MagicAES.MUMESAG IN event) & 
  3914.                (mess[0] = 4721H) (* VA_WINDOPEN *)
  3915.             THEN
  3916.               started := started OR (mess[3] # 0);
  3917.             END;
  3918.           UNTIL {MagicAES.MUTIMER} = event;
  3919.           MagicAES.WindUpdate (MagicAES.BEGUPDATE);
  3920.         ELSE
  3921.           started := FALSE;
  3922.         END;
  3923.         IF ~started & OpenEditor (path, name, wdw, FALSE)
  3924.         THEN
  3925.           Strings.Assign (path, InPath, v.bool);
  3926.         END;
  3927.       ELSIF isNumber (para)
  3928.       THEN
  3929.         IF firstNumber 
  3930.         THEN
  3931.           p := 0;
  3932.           eLine := StrConv.StrToLInt (para, p, v.bool);
  3933.           firstNumber := FALSE;
  3934.         ELSE
  3935.           p := 0;
  3936.           eRow := StrConv.StrToInt (para, p, v.bool);
  3937.           numberRead := TRUE;
  3938.         END;
  3939.       ELSE
  3940.         (* Muž Fehlermeldung sein *)
  3941.         Strings.Assign (para, eMsg, v.bool);
  3942.         IF Strings.Pos ('"',eMsg,0) >= 0
  3943.         THEN
  3944.           (* Stringanfang oder Ende in Parameter *)
  3945.           REPEAT
  3946.             Strings.Append (' ',eMsg, v.bool);
  3947.             INC (i);
  3948.             DEC (params);
  3949.             mtCommand.ParamString (i, para);
  3950.             Strings.Append (para, eMsg, v.bool);
  3951.           UNTIL (params = 0) OR (Strings.Pos ('"',para,0)>=0)
  3952.         END;
  3953.         IF numberRead & (wdw > 0)
  3954.         THEN
  3955.           CatEdit.SetError (wdw, eLine, eRow, eMsg, TRUE);
  3956.           firstNumber := TRUE;
  3957.           numberRead := FALSE;
  3958.         ELSIF ~firstNumber & (wdw > 0)
  3959.         THEN
  3960.           CatEdit.SetError (wdw, eLine, 0, eMsg, TRUE);
  3961.           allSet := TRUE;
  3962.           firstNumber := TRUE;
  3963.         ELSIF (wdw > 0)
  3964.         THEN
  3965.           CatEdit.SetError (wdw, 1, 0, eMsg, TRUE);
  3966.         END;
  3967.       END;
  3968.       INC (i);
  3969.       DEC(params);
  3970.     END;
  3971.     IF started 
  3972.     THEN
  3973.       TermProcess (0);
  3974.     END;
  3975.     IF ~firstNumber OR numberRead
  3976.     THEN
  3977.       IF numberRead 
  3978.       THEN
  3979.         CatEdit.SetError (wdw, eLine, eRow, eMsg, TRUE);
  3980.       ELSE
  3981.         CatEdit.SetError (wdw, eLine, 0, eMsg, TRUE);
  3982.       END;
  3983.     END;
  3984.     CatEdit.EditRestorePos ();
  3985.  
  3986.     IF ConfVars.GetConfigString (cShortFile, lastShort)
  3987.     THEN
  3988.       CatEdit.ReadShortkeyFile (lastShort);
  3989.       shortFileRead := TRUE;
  3990.     END;
  3991.   
  3992.     ConfVars.GetConfDefStr (cErrMask, errMask, '');
  3993.  
  3994.     IF MagicCookie.FindCookie (magicPCCookie, v.lcard) 
  3995.     (* Jetzt k”nnen wir endlich normal weitermachen *)
  3996.     THEN
  3997.       ConfVars.GetConfDefBool (cMagicPCKeys, v.bool, TRUE);
  3998.       IF v.bool
  3999.       THEN
  4000.         WdwManager.SetMagicPCKeyTranslation (TRUE);
  4001.       END;
  4002.     END;
  4003.  
  4004.     (* XACC initialisieren *)
  4005.     MagicAES.WindUpdate(MagicAES.ENDUPDATE); (* wg. sofort wieder aus.. *)
  4006.     ProtoInit();
  4007.  
  4008.     handlePendingEvents();    (* Events behandeln *)
  4009.  
  4010.     (* SE-Protokoll initialisieren *)
  4011.     SeProtoInit();
  4012.  
  4013.     handlePendingEvents();    (* Events behandeln! *)
  4014.  
  4015.     WdwManager.InstallGlobalMenu (menu, msgHandler);
  4016.  
  4017.     MagicAES.WindUpdate(MagicAES.BEGUPDATE); (* wg. sofort wieder aus.. *)
  4018.  
  4019.     mtAppl.MouseArrow;
  4020.     mouse := TRUE;
  4021.     WITH mrect DO
  4022.       x := 0; y := 0; w := 1; h := 1;
  4023.     END;
  4024.     
  4025.     WHILE ~quitProg DO
  4026.     
  4027.       enableMenuItems();
  4028.  
  4029.       MagicAES.WindUpdate(MagicAES.ENDUPDATE);
  4030.  
  4031.       IF PendingKey()
  4032.       THEN
  4033.         event := {MagicAES.MUKEYBD};
  4034.         PopKey(moKState, scan, char);
  4035.       ELSE
  4036.         IF mouse
  4037.         THEN
  4038.           event := MagicAES.EvntMulti(
  4039.                    {MagicAES.MUKEYBD, MagicAES.MUBUTTON, MagicAES.MUMESAG, MagicAES.MUTIMER},
  4040.                     259, {1,0},{}, MagicAES.LeaveRect, mrect, 0,dr, mess, 350,0,
  4041.                     moX, moY, moButton, kReturn, moKState, SCAN, CH, bReturn);
  4042.   
  4043.         ELSE
  4044.           event := MagicAES.EvntMulti(
  4045.                    {MagicAES.MUKEYBD, MagicAES.MUBUTTON, MagicAES.MUM1, MagicAES.MUMESAG, MagicAES.MUTIMER},
  4046.                     259, {1,0},{}, MagicAES.LeaveRect, mrect, 0,dr, mess, 350,0,
  4047.                     moX, moY, moButton, kReturn, moKState, SCAN, CH, bReturn);
  4048.         END;
  4049.         WITH mrect DO
  4050.           x := moX; y := moY;
  4051.         END;
  4052.         SplitWordToByte(kReturn, scan, char);
  4053.       END;
  4054.       
  4055.       MagicAES.WindUpdate(MagicAES.BEGUPDATE);
  4056.       
  4057.       handleEvents();
  4058.  
  4059.     END; (* WHILE ~quitProg *)
  4060.  
  4061.  
  4062. (* ---------------------------------------------------------------------- *)
  4063.  
  4064.     IF autoSavePos THEN SavePrefs() END;
  4065.   ELSE
  4066.     SendTerminate();
  4067.   END;
  4068.   TermProcess (termCode);
  4069. END Fred.
  4070.